package com.power.pipeengine.Constraint;

import java.util.*;
import com.power.pipeengine.Entity.*;
import com.power.pipeengine.InputData.*;
import com.power.pipeengine.LPModel.*;
import com.power.pipeengine.Variable.*;
import com.power.pipeengine.*;
import com.power.lpsolver.LPSolve.*;

/**
 *
 * <p>Title: PIPE Engine</p>
 * <p>Description: Global Planning Optimization Engine</p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Company: Paraster, Inc.</p>
 * @author Wei Tan
 * @version 1.0
 */

/**
 * InventoryConstraint type deals with the inventory balance at each inventory
 * facility for each bucket.
 */
public class InventoryConstraint
    extends Constraint {
  static ResourceBundle res = ResourceBundle.getBundle(
      "com.power.pipeengine.Res",
      EngineConfig.getInstance().getLocale());
  private static final InventoryConstraint INSTANCE =
      new InventoryConstraint();

  /**
   * Sole class constructor.
   */
  private InventoryConstraint() {
    setConstraintType(res.getString("INVENTORY_CONSRTAINT"));
  }

  public static InventoryConstraint getInstance() {
    return INSTANCE;
  }

  /**
   * stores all inventory constraints.
   */
  private Vector _constraints = new Vector();

  /**
   * Gets all inventory constraints.
   * @return the inventory constraint vector.
   */
  public Vector getConstraints() {
    return _constraints;
  }

  /**
   * Builds all inventory constraint at each facility.
   */
  public void buildConstraints() {
    super.publishMessage();
    Vector invFacilities = DataModel.getInstance().getFacilities().
        getInvFacilities();

    for (int i = 0; i < invFacilities.size(); i++) {
      Facility f = (Facility) invFacilities.elementAt(i);
      Vector products = f.getProducts();
      for (int j = 0; j < products.size(); j++) {
        Product p = (Product) products.elementAt(j);
        buildConstraintsByBucket(f, p);
      }
    }
  }

  /**
   * Builds inventory constraint at a given facility for a given product by
   * buckets.
   * @param f the facility where the constraints are built.
   * @param p the product for which the constraints are built.
   */
  public void buildConstraintsByBucket(Facility f, Product p) {
    Vector buckets = DataModel.getInstance().getCalendar().getBuckets();
    Vector producingRoutes = p.getProducingRoutes();
    Vector sourcingRoutes = p.getSourcingRoutes();
    InventoryVariable invVar = InventoryVariable.getInstance();
    AllocationVariable allocVar = AllocationVariable.getInstance();
    StartsVariable startsVar = StartsVariable.getInstance();
    OutsVariable outsVar = OutsVariable.getInstance();
    BackorderVariable backOrderVar = BackorderVariable.getInstance();
    BackorderOneVariable backOrderOneVar = BackorderOneVariable.getInstance();
    BackorderTwoVariable backOrderTwoVar = BackorderTwoVariable.getInstance();
    ShipOutVariable shipOutVar = ShipOutVariable.getInstance();
    ReceivingVariable rcvVar = ReceivingVariable.getInstance();
    Inventories inventories = DataModel.getInstance().getInventories();
    MinInventories minInvs = DataModel.getInstance().getMinInventories();
    MinInvVariable minInvVar = MinInvVariable.getInstance();
    LostSaleVariable lostSaleVar = LostSaleVariable.getInstance();

    int firstDmdBucket = p.getFirstDemandPeriod();
    boolean hasDemand = p.hasDemand();

    Model mdl = Model.getInstance();
    MemoryManager memMgr = MemoryManager.getInstance();

    for (int i = 0; i < buckets.size(); i++) {

      //add a new constraint to LP solver
      int rowNumber = Model.getInstance().getNumberOfRows();
      //com.power.lpsolver.LPSolve.Constraint con =
      // new com.power.lpsolver.LPSolve.Constraint( "I" + rowNumber + i, rowNumber );
      com.power.lpsolver.LPSolve.Constraint con =
          new com.power.lpsolver.LPSolve.Constraint("I" + rowNumber,
          rowNumber);

      Bucket b = (Bucket) buckets.elementAt(i);
      Bucket prevBucket = null;
      Bucket twoBucketsPrior = null;
      Bucket threeBucketsPrior = null;

      if (i >= 1) {
        prevBucket = (Bucket) buckets.elementAt(i - 1);
        //beginning inventory
        int colIdx = mdl.getModelVariables().addVariable(invVar.getVariable(f,
            p, prevBucket));
        Element elem = memMgr.getElement();
        elem.setProperties(colIdx, 1.0);
        con.addElement(elem);
        this.addMPSElem(con, colIdx, elem);
        //invVar.setObjElement( f, p, prevBucket, true );

      }

      if (i >= 2) {
        twoBucketsPrior = (Bucket) buckets.elementAt(i - 2);
      }

      if (i >= 3) {
        threeBucketsPrior = (Bucket) buckets.elementAt(i - 3);
      }

      //replenishment during the period
      for (int j = 0; j < producingRoutes.size(); j++) {
        Route r = (Route) producingRoutes.elementAt(j);
        if (r.getDestFacilityID() != f.getFacilityID())
          continue;
        if (r.getFacility().getNumWorkingDaysForBucket(b.getBucketID()) == 0) {
          continue;
        }
        Bucket bucket = outsVar.getRouteStartBucket(r, p, b);
        if (bucket != null) {
          int colIdx = mdl.getModelVariables().addVariable(outsVar.getVariable(
              p, b));
          Element elem = memMgr.getElement();
          elem.setProperties(colIdx, 1.0);
          con.addElement(elem);
          this.addMPSElem(con, colIdx, elem);
        }
      }

      //Products shipped in from other inventory points
      //-- need to consider shipment delay time for "b"
      //use mapped shipout variables as receiving variables
      Enumeration origFacilities = f.getOrignatingFacilities().elements();
      while (origFacilities.hasMoreElements()) {
        Vector shipments = (Vector) origFacilities.nextElement();
        for (int idx = 0; idx < shipments.size(); idx++) {
          Shipment s = (Shipment) shipments.elementAt(idx);
          /*if( EngineConfig.getInstance().getCollator().compare(
                s.getToProduct().getProductID(),
                p.getProductID() ) == 0 ) {*/
          if (s.getToProduct().getProductNumber() == p.getProductNumber()) {

            Bucket shipStartBucket = rcvVar.getShippingStartBucket(s, b);
            if (shipStartBucket != null) {
              /*String varName = shipOutVar.getVariable( s.getFromFacility(),
                      f,
                      p,
                      shipStartBucket );*/
              String varName = rcvVar.getVariable(s.getFromFacility(),
                                                  f,
                                                  p,
                                                  b);

              int colIdx = mdl.getModelVariables().addVariable(varName);
              Element elem = memMgr.getElement();
              elem.setProperties(colIdx, 1.0);
              con.addElement(elem);
              this.addMPSElem(con, colIdx, elem);
            }
          }
        }
      }

      //allocation during the period
      for (int k = 0; k < sourcingRoutes.size(); k++) {
        Route r = (Route) sourcingRoutes.elementAt(k);
        if (r.getSrcingFacilityID() != f.getFacilityID())
          continue;

        if (r.getFacility().getNumWorkingDaysForBucket(b.getBucketID()) == 0) {
          continue;
        }
        String varName = allocVar.getVariable(f, p, r, b);

        int colIdx = mdl.getModelVariables().addVariable(varName);
        Element elem = memMgr.getElement();
        elem.setProperties(colIdx, -1.0);
        con.addElement(elem);
        this.addMPSElem(con, colIdx, elem);
      }

      //products shipped out to other inventory points
      Enumeration destFacilities = f.getDestinationFacilities().elements();
      while (destFacilities.hasMoreElements()) {
        Vector shipments = (Vector) destFacilities.nextElement();
        for (int idx = 0; idx < shipments.size(); idx++) {
          Shipment s = (Shipment) shipments.elementAt(idx);
          /*if( EngineConfig.getInstance().getCollator().compare(
                s.getFromProduct().getProductID(),
                p.getProductID() ) == 0 )  {*/
          if (s.getFromProduct().getProductNumber() == p.getProductNumber()) {
            String varName = shipOutVar.getVariable(f,
                s.getToFacility(),
                p,
                b);

            int colIdx = mdl.getModelVariables().addVariable(varName);
            Element elem = memMgr.getElement();
            elem.setProperties(colIdx, -1.0);
            con.addElement(elem);
            this.addMPSElem(con, colIdx, elem);
          }
        }
      }

      int colIdx;
      Element elem = null;

      //if demanded, add backorder, overproduce variables
      if (hasDemand &&
          (b.getBucketID() >= firstDmdBucket)) {
        // if( p.hasDemand( b ) ) {
        //add 1 to priority to avoid division by zero.
        int dmdPriority = p.getDemandPriority(b) + 1;
        //back order variable in this bucket
        String bVar = backOrderVar.getVariable(f, p, b);
        colIdx = mdl.getModelVariables().addVariable(bVar);
        if (EngineConfig.getInstance().isMaxOnTimeDelivery()) {
          backOrderVar.setObjElement(bVar, p, b);
        }

        elem = memMgr.getElement();
        elem.setProperties(colIdx, 1.0);
        con.addElement(elem);
        this.addMPSElem(con, colIdx, elem);

        //back order filled in the bucket after next
        String bOneVar = backOrderOneVar.getVariable(f, p, b);
        colIdx = mdl.getModelVariables().addVariable(bOneVar);
        if (EngineConfig.getInstance().isMaxOnTimeDelivery()) {
          backOrderOneVar.setObjElement(bOneVar, p, b);
        }

        elem = memMgr.getElement();
        elem.setProperties(colIdx, 1.0);
        con.addElement(elem);
        this.addMPSElem(con, colIdx, elem);

        //back order filled in the third bucket from this
        String bTwoVar = backOrderTwoVar.getVariable(f, p, b);
        colIdx = mdl.getModelVariables().addVariable(bTwoVar);
        if (EngineConfig.getInstance().isMaxOnTimeDelivery()) {
          backOrderTwoVar.setObjElement(bTwoVar, p, b);
        }

        elem = memMgr.getElement();
        elem.setProperties(colIdx, 1.0);
        con.addElement(elem);
        this.addMPSElem(con, colIdx, elem);

        //lost sale variable for this bucket (only)
        /*String lsVar = lostSaleVar.getVariable( f, p, b );
             colIdx = mdl.getModelVariables().addVariable( lsVar );
             if( EngineConfig.getInstance().isMaxOnTimeDelivery() ) {
            lostSaleVar.setObjElement( lsVar, p, b );
                                         }
                                         elem = memMgr.getElement();
                                         elem.setProperties( colIdx, 1.0 );
                                         con.addElement( elem );
             this.addMPSElem( con.getMPSRowName(), colIdx, elem );*/
        //  }

        //back order variable for last bucket
        if (b.getBucketID() > firstDmdBucket /*&&
                                            p.hasDemand( prevBucket ) */) {
          String varName = backOrderVar.getVariable(f, p, prevBucket);
          colIdx = mdl.getModelVariables().addVariable(varName);
          elem = memMgr.getElement();
          elem.setProperties(colIdx, -1.0);
          con.addElement(elem);
          this.addMPSElem(con, colIdx, elem);
          if (EngineConfig.getInstance().isMaxProfit()) {
            backOrderVar.setObjElement(varName, p, prevBucket);
          }
        }

        //back order variable for the bucket before last
        if (b.getBucketID() > (firstDmdBucket + 1) /*&&
                                            p.hasDemand( twoBucketsPrior ) */) {
          String varName = backOrderOneVar.getVariable(f, p, twoBucketsPrior);

          colIdx = mdl.getModelVariables().addVariable(varName);
          elem = memMgr.getElement();
          elem.setProperties(colIdx, -1.0);
          con.addElement(elem);
          this.addMPSElem(con, colIdx, elem);
          if (EngineConfig.getInstance().isMaxProfit()) {
            backOrderVar.setObjElement(varName, p, twoBucketsPrior);
          }
        }

        //back order variable for two buckets before
        if (b.getBucketID() > (firstDmdBucket + 2) /*&&
                                            p.hasDemand( threeBucketsPrior ) */) {
          String varName = backOrderTwoVar.getVariable(f, p, threeBucketsPrior);

          colIdx = mdl.getModelVariables().addVariable(varName);
          elem = memMgr.getElement();
          elem.setProperties(colIdx, -1.0);
          con.addElement(elem);
          this.addMPSElem(con, colIdx, elem);
          if (EngineConfig.getInstance().isMaxProfit()) {
            backOrderVar.setObjElement(varName, p, threeBucketsPrior);
          }
        }

      }

      //ending inventory
      colIdx = mdl.getModelVariables().addVariable(invVar.getVariable(f, p, b));
      elem = memMgr.getElement();
      elem.setProperties(colIdx, -1.0);
      con.addElement(elem);
      this.addMPSElem(con, colIdx, elem);
      if (i < (buckets.size() - 1)) {
        //invVar.setObjElement( f, p, b, false );
      }

      //MinInventory requirement
      if (minInvs.hasMinInvReqmt(p, b)) {
        colIdx = mdl.getModelVariables().addVariable(minInvVar.getVariable(f, p,
            b));
        elem = memMgr.getElement();
        elem.setProperties(colIdx, -1.0);
        con.addElement(elem);
        this.addMPSElem(con, colIdx, elem);
      }

      //RHS
      double invQty = inventories.getInventoryQty(p.getProductID(),
                                                  f.getFacilityID(),
                                                  b.getBucketID());
      if (b.getBucketID() < firstDmdBucket) {
        con.setRHS( -invQty);
      }
      else {
        double rhs = -invQty + p.getDemand(b.getBucketID());
        con.setRHS(rhs);
      }

      //store constraint
      con.setSign("=");

      mdl.addConstraint(con);
    }
  }

}