package com.power.pipeengine.DispatchReport;

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

import java.util.*;
import java.io.*;
import com.power.pipeengine.Report.*;
import com.power.pipeengine.Entity.*;
import com.power.util.Message.*;
import com.power.util.urltools.*;
import com.power.pipeengine.DispatchReportMap.*;
import com.power.pipeengine.InputData.*;
import com.power.pipe.*;
import java.text.*;

public class DispatchList {

  private static final DispatchList INSTANCE =
      new DispatchList();

  // Private constructor supresses
  // default public constructor
  private DispatchList() {
  }

  public static DispatchList getInstance() {
    return INSTANCE;
  }

  private Date getMappedStartTime(int bucketID) {
    Vector bucketStartDates = CalendarMap.getInstance().getBucketStartDates();

    return (Date) bucketStartDates.elementAt(bucketID - 1);
  }

  private int getSeqInDay(int bucketID) {
    Vector seqInBucket = CalendarMap.getInstance().getSeqInBucket();

    return ( (Integer) seqInBucket.elementAt(bucketID - 1)).intValue();
  }

  public void createReport() {
    ProductionStartsSchedule startsSchedule = ProductionStartsSchedule.
        getInstance();
    try {
      //WorkingHours.getInstance().readData();
      OrderDetailsManHourMap.getInstance().readData();
      //PeriodDateMap.getInstance().readData();
      ProcessCapabilityTable.getInstance().readData();
      EmployeeAvailability.getInstance().readData();
      EquipmentCapabilityTable.getInstance().readData();
    }
    catch (Exception e) {
      System.out.println("Reading error: " + e.getMessage());
    }
    DataModel.getInstance().getProductDemands().genLastRoutes();

    netOutWIP();

    allocateDetailedOrders();

    groupScheduleByBucket();

    assignEmployee();

    assignStartEndTime();

    setDefaultTime();

    //sortStarts();
    //this.sortStartsByEmployee();
    //assignEquipment();
    //assignEquipment2();
    groupStartsByEmployee();
    assignEquipmentSimple();

    groupScheduleByRoute();
    findNextOperator();
    writeDispatchList();
    writeNextOperator();
    createSummaryReport();

  }

  private String urlAddr = GlobalConfig.getInstance().getLPServerURL() +
      "com.power.pipeengine.LP_ReadWriteFile";

  private void writeDispatchList() {
    //Vector[] startsSchedules = ProductionStartsSchedule.getInstance().getStartsSchedules();
    Vector[] startsSchedules = schedulesGroupedByBucket;
    StringBuffer content = new StringBuffer();
    for (int i = 0; i < startsSchedules.length; i++) {
      Vector allStarts = (Vector) startsSchedules[i];
      if (null == allStarts || allStarts.size() == 0)
        continue;
      for (int j = 0; j < allStarts.size(); j++) {
        StartsSchedule aSchedule = (StartsSchedule) allStarts.elementAt(j);
        content.append(aSchedule.getSchedule());
      }
    }

    URLFileWriter.getInstance().write(urlAddr,
                                      GlobalConfig.getInstance().
                                      getDirectOutputDir() + "dispatchlist.csv",
                                      "WriteModel",
                                      content.toString());

  }

  private void writeNextOperator() {
    Vector[] startsSchedules = schedulesGroupedByBucket;
    int lineNumOffset = getMaxAutoIDInDispatchList();

    StringBuffer content = new StringBuffer();
    for (int i = 0; i < startsSchedules.length; i++) {
      Vector allStarts = (Vector) startsSchedules[i];
      if (null == allStarts || allStarts.size() == 0)
        continue;
      for (int j = 0; j < allStarts.size(); j++) {
        StartsSchedule aSchedule = (StartsSchedule) allStarts.elementAt(j);
        content.append(aSchedule.getNextOperators(lineNumOffset));
      }
    }

    URLFileWriter.getInstance().write(urlAddr,
                                      GlobalConfig.getInstance().
                                      getDirectOutputDir() + "nextop.csv",
                                      "WriteModel",
                                      content.toString());

  }

  int maxIndex = -1;
  public int getMaxAutoIDInDispatchList() {
    if (maxIndex >= 0)
      return maxIndex;

    BufferedReader b = null;
    try {
      b = URLFileReader.getInstance().getReaderForURL(urlAddr,
          "ReadModel",
          GlobalConfig.getInstance().getDirectInputDir() +
          "maxautoidindispatchlist.csv");
    }
    catch (Exception e) {
      MessageArea.getInstance().addMessage(
          "Error opening file: maxautoidindispatchlist.csv\n");
    }

    try {
      String line = b.readLine();
      maxIndex = new Integer(line).intValue();
    }
    catch (Exception e) {
      MessageArea.getInstance().addMessage(
          "Error reading file: maxautoidindispatchlist.csv\n");
    }

    return maxIndex;
  }

  private StartsSchedule getNextSchedule(Vector aVec, int curIdx) {
    if (curIdx >= (aVec.size() - 1)) {
      return null;
    }

    return (StartsSchedule) aVec.elementAt(curIdx + 1);
  }

  private void removeZeroEntries() {
    Vector[] startsSchedules = ProductionStartsSchedule.getInstance().
        getStartsSchedules();

    for (int i = 0; i < startsSchedules.length; i++) {
      Vector starts = (Vector) startsSchedules[i];
      if (null == starts || starts.size() == 0)
        continue;

      for (int j = 0; j < starts.size(); j++) {
        StartsSchedule aSchedule = (StartsSchedule) starts.elementAt(j);
        if (aSchedule.getStartsValue() == 0.0) {
          starts.remove(j);
          j--;
        }
      }
    }
  }

  private Vector splitedStarts = new Vector();
  public Vector getSplitedStarts() {
    return splitedStarts;
  }

  public void netOutWIP() {
    try {
      CashmereWip.getInstance().readData();
    }
    catch (Exception e) {
      System.out.println("Reading error: " + e.getMessage());
    }
    Vector wips = CashmereWip.getInstance().getWIPs();
    for (int i = 0; i < wips.size(); i++) {
      Object[] aWip = (Object[]) wips.elementAt(i);
      String orderID = (String) aWip[0];
      String styleID = (String) aWip[1];
      Integer nextRteID = (Integer) aWip[2];
      Integer qty = (Integer) aWip[3];
      Route r = DataModel.getInstance().getRoutes().getRoute(nextRteID.intValue());
      Vector styles = (Vector) OrderDetailsManHourMap.getInstance().getStyles(
          orderID, styleID);
      if (null == styles)
        continue;
      for (int j = 0; j < styles.size(); j++) {
        Style aStyle = (Style) styles.elementAt(j);
        int rteID = aStyle.getRouteID().intValue();
        if (r.isAPrevRoute(rteID)) {
          aStyle.reduceQty(qty.intValue());
          //System.out.println("Style neted out: " + aStyle.getOrderID() + "\t" +
                             //aStyle.getStyleID());
        }

      }
    }

  }

  public void allocateDetailedOrders() {

    removeZeroEntries();
    Vector[] startsSchedules = ProductionStartsSchedule.getInstance().
        getStartsSchedules();
    Enumeration allOdrs = OrderDetailsManHourMap.getInstance().getAllStyles().
        elements();
    ProductDemands prodDmds = DataModel.getInstance().getProductDemands();

    while (allOdrs.hasMoreElements()) {
      Style aStyle = (Style) allOdrs.nextElement();
      //Vector allStarts = (Vector) startsSchedules[ rteID.intValue() - 1 ];
      Integer rteID = aStyle.getRouteID();
      if (null == startsSchedules[rteID.intValue() - 1])
        continue;
      Enumeration allStarts = startsSchedules[rteID.intValue() - 1].elements();
      Vector allStartsVec = (Vector) startsSchedules[rteID.intValue() - 1];
      if (allStarts == null || allStartsVec.size() == 0) {
        continue;
      }

      Vector tmpVec = new Vector();

      int qty = 0;
      StartsSchedule aSchedule = null;
      //get all until meeting style qty rqmt
      while (allStarts.hasMoreElements()) {
        aSchedule = (StartsSchedule) allStarts.nextElement();
        if (aSchedule.isAssigned())
          continue;
        if (null == aSchedule)
          break;
        tmpVec.add(aSchedule);
        qty += (int) aSchedule.getStartsValue();
        if (qty >= aStyle.getQuantity())
          break;
      }
      if (qty == 0) {
        aStyle.setProcessedQty(0);
        continue;
      }

      if (qty > aStyle.getQuantity()) {
        double extra = (double) (qty - aStyle.getQuantity());
        StartsSchedule tmpSchedule = new StartsSchedule(
            aSchedule.getBucketID(),
            aSchedule.getRouteID(),
            (int) extra);
        tmpSchedule.processStyle( aStyle, (int) extra );
        int index = allStartsVec.indexOf(aSchedule);
        allStartsVec.insertElementAt(tmpSchedule, index + 1);
        //allStartsVec.add( tmpSchedule );
        splitedStarts.add(tmpSchedule);
        tmpSchedule.setParent(aSchedule);
        aSchedule.reviseStarts(aSchedule.getStartsValue() - extra);
        aStyle.setProcessedQty(aStyle.getQuantity());
      }
      else {
        aStyle.setProcessedQty(qty);
      }

      aStyle.setLastStartsBucket(aSchedule.getBucketID());

      for (int j = 0; j < tmpVec.size(); j++) {
        StartsSchedule schedule = (StartsSchedule) tmpVec.elementAt(j);
        schedule.processStyle(aStyle, (int) schedule.getStartsValue());
        schedule.setAssignedStatus(true);
      }

    }
  }

  private Vector[] schedulesGroupedByBucket = new Vector[DataModel.getInstance().
      getCalendar().getTotalNumOfBuckets()];
  private void groupScheduleByBucket() {
    Vector[] startsSchedules = ProductionStartsSchedule.getInstance().
        getStartsSchedules();

    for (int i = 0; i < startsSchedules.length; i++) {
      Vector starts = (Vector) startsSchedules[i];
      if (null == starts || starts.size() == 0)
        continue;

      for (int j = 0; j < starts.size(); j++) {
        StartsSchedule aSchedule = (StartsSchedule) starts.elementAt(j);
        if (null == schedulesGroupedByBucket[aSchedule.getBucketID() - 1]) {
          schedulesGroupedByBucket[aSchedule.getBucketID() - 1] = new Vector();
        }

        Vector schedules = schedulesGroupedByBucket[aSchedule.getBucketID() - 1];
        boolean inserted = false;
        for (int k = 0; k < schedules.size(); k++) {
          StartsSchedule tmpSchedule = (StartsSchedule) schedules.elementAt(k);
          Vector prevRoutes = DataModel.getInstance().getRoutes().getRoute(
              tmpSchedule.getRouteID()).getPrevRoutes();
          if (null == prevRoutes) {
            schedules.add(aSchedule);
            inserted = true;
            break;
          }

          for (int m = 0; m < prevRoutes.size(); m++) {
            Route r = (Route) prevRoutes.elementAt(m);
            if (r.getRouteID() == aSchedule.getRouteID()) {
              schedules.insertElementAt(aSchedule, k);
              inserted = true;
              break;
            }
          }
          if (inserted)
            break;

          prevRoutes = DataModel.getInstance().getRoutes().getRoute(aSchedule.
              getRouteID()).getPrevRoutes();
          if (null == prevRoutes) {
            schedules.insertElementAt(aSchedule, k);
            inserted = true;
            break;
          }

          for (int m = 0; m < prevRoutes.size(); m++) {
            Route r = (Route) prevRoutes.elementAt(m);
            if (r.getRouteID() == tmpSchedule.getRouteID()) {
              schedules.insertElementAt(aSchedule, k + 1);
              inserted = true;
              break;
            }
          }

        }
        if (!inserted) {
          schedulesGroupedByBucket[aSchedule.getBucketID() - 1].add(aSchedule);
        }
      }
    }

  }

  private void setDefaultTime() {
    Vector[] startsSchedules = schedulesGroupedByBucket;
    ProcessCapabilityTable pct = ProcessCapabilityTable.getInstance();

    for (int i = 0; i < startsSchedules.length; i++) {
      Vector starts = (Vector) startsSchedules[i];
      if (null == starts || starts.size() == 0)
        continue;

      for (int j = 0; j < starts.size(); j++) {
        StartsSchedule aSchedule = (StartsSchedule) starts.elementAt(j);