if (aSchedule.getAssignedEmployee() < 0) {
          aSchedule.setDefaultTimeInterval();
        }

      }
    }
  }

  private void notSufficientEmployees() {
    Vector[] startsSchedules = schedulesGroupedByBucket;
    int cnt = 0;
    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);
        cnt++;
        if (aSchedule.getAssignedEmployee() < 0) {

        }
      }
    }
  }

  private Vector[] assignedSchedulesByRoute = new Vector[DataModel.getInstance().
      getRoutes().getNumberOfRoutes()];

  private void insertIntoAssignedRoutes(StartsSchedule aSchedule) {
    Vector schedules = (Vector) assignedSchedulesByRoute[aSchedule.getRouteID() -
        1];
    if (null == schedules) {
      schedules = new Vector();
      schedules.add(aSchedule);
      return;
    }

    for (int i = 0; i < schedules.size(); i++) {
      StartsSchedule tmpSchedule = (StartsSchedule) schedules.elementAt(i);
      if (aSchedule.getBucketID() < tmpSchedule.getBucketID()) {
        schedules.insertElementAt(aSchedule, i);
        return;
      }
    }

    schedules.add(aSchedule);
  }

  private int getCumStartsByBucket(int rteID, int bucketID) {
    Vector schedules = (Vector) assignedSchedulesByRoute[rteID - 1];
    if (null == schedules || schedules.size() == 0) {
      return 0;
    }

    int cnt = 0;
    for (int i = 0; i < schedules.size(); i++) {
      StartsSchedule tmpSchedule = (StartsSchedule) schedules.elementAt(i);
      if (tmpSchedule.getBucketID() < bucketID) {
        cnt += tmpSchedule.getQuantity();
      }
    }

    return cnt;
  }

  private int getCumStartsOfPrevRoutes(int rteID, int bucketID) {
    Vector prevRoutes = DataModel.getInstance().getRoutes().getRoute(rteID).
        getPrevRoutes();
    if (null == prevRoutes || prevRoutes.size() == 0)
      return -1;
    if (prevRoutes.size() == 1) {
      Route r = (Route) prevRoutes.elementAt(0);
      return getCumStarts(r.getRouteID(), bucketID);
    }

    int minCumStarts = Integer.MAX_VALUE;

    for (int i = 0; i < prevRoutes.size(); i++) {
      Route aRoute = (Route) prevRoutes.elementAt(i);
      int cumStarts = getCumStarts(aRoute.getRouteID(), bucketID);
      if (cumStarts < minCumStarts) {
        minCumStarts = cumStarts;
      }
    }

    return minCumStarts;
  }

  private int getCumStarts(int rteID, int bucketID) {
    Vector rteArray = assignedSchedulesByRoute[rteID - 1];
    if (null == rteArray || rteArray.size() == 0) {
      return 0;
    }
    int cumStarts = 0;
    for (int i = 0; i < rteArray.size(); i++) {
      StartsSchedule aSchedule = (StartsSchedule) rteArray.elementAt(i);
      if (aSchedule.getBucketID() < bucketID) {
        cumStarts += aSchedule.getStartsValue();
      }
    }
    return cumStarts;
  }

  private void assignEmployee() {
    Vector[] startsSchedules = schedulesGroupedByBucket;
    ProcessCapabilityTable pct = ProcessCapabilityTable.getInstance();
    int cntc = 0;
    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);

        int cumPrevStarts = getCumStartsOfPrevRoutes(aSchedule.getRouteID(),
            aSchedule.getBucketID());
        if (cumPrevStarts > 0) {
          int myCumStarts = this.getCumStartsByBucket(aSchedule.getRouteID(),
              aSchedule.getBucketID());
          int diff = myCumStarts + aSchedule.getQuantity() - cumPrevStarts;
          if (diff > 0) {
            StartsSchedule tmpSchedule = aSchedule.getSplitedSchedule(diff);
            accumToNextBucket(tmpSchedule);
          }
        }

        int leftOverQty = pct.getEmployee(aSchedule);

        if (leftOverQty < 0) {
          if (leftOverQty <= -9000) {
            if (aSchedule.getBucketID() ==
                DataModel.getInstance().getCalendar().getTotalNumOfBuckets()) {
              continue;
            }
            int size = starts.size();
            aSchedule = (StartsSchedule) starts.remove(j);
            accumToNextBucket(aSchedule);
            if (j == size - 1) {
              break;
            }
            else {
              j--;
            }
          }
          continue;
        }
        else if (leftOverQty > 0) {
          StartsSchedule tmpSchedule = aSchedule.getSplitedSchedule(leftOverQty);
          starts.insertElementAt(tmpSchedule, j + 1);
          insertIntoAssignedRoutes(aSchedule);
        }
        else if (leftOverQty == 0) {
          insertIntoAssignedRoutes(aSchedule);
        }

      }
    }
  }

  private void accumToNextBucket(StartsSchedule aSchedule) {
    Vector[] startsSchedules = schedulesGroupedByBucket;

    //return if last already last bucket
    if (aSchedule.getBucketID() >= startsSchedules.length) {
      return;

    }
    Vector starts = (Vector) startsSchedules[aSchedule.getBucketID()];
    if (null == starts || starts.size() == 0) {
      Vector vec = new Vector();
      startsSchedules[aSchedule.getBucketID()] = vec;
      vec.add(aSchedule);
      aSchedule.modifyBucketID(aSchedule.getBucketID() + 1);
      return;
    }

    for (int j = 0; j < starts.size(); j++) {
      StartsSchedule tmpSchedule = (StartsSchedule) starts.elementAt(j);
      if (tmpSchedule.getOrderID().equals(aSchedule.getOrderID()) &&
          tmpSchedule.getStyleID().equals(aSchedule.getStyleID()) &&
          tmpSchedule.getProcessID() == aSchedule.getProcessID()) {
        tmpSchedule.augmentQuantity(aSchedule.getQuantity());
        return;
      }

    }

    starts.add(aSchedule);
    aSchedule.modifyBucketID(aSchedule.getBucketID() + 1);
  }

  private void sortStarts() {
    Vector[] startsSchedules = schedulesGroupedByBucket;
    //Vector[] startsSchedules = ProductionStartsSchedule.getInstance().getStartsSchedules();
    EquipmentCapabilityTable ect = EquipmentCapabilityTable.getInstance();

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

      Vector tmpStarts = new Vector();

      for (int j = 0; j < starts.size(); j++) {
        StartsSchedule aSchedule = (StartsSchedule) starts.elementAt(j);
        for (int k = 0; k < tmpStarts.size(); k++) {
          StartsSchedule tmpSchedule = (StartsSchedule) tmpStarts.elementAt(k);
          if (!aSchedule.getStartTime().after(tmpSchedule.getStartTime())) {
            tmpStarts.insertElementAt(aSchedule, k);
            aSchedule = null;
            break;
          }
        }
        if (null != aSchedule) {
          tmpStarts.add(aSchedule);
        }
      }

      startsSchedules[i] = tmpStarts;
    }
  }

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

      startsSchedules[i] = new Vector();
      for (int j = 0; j < starts.size(); j++) {
        StartsSchedule aSchedule = (StartsSchedule) starts.elementAt(j);
        boolean inserted = false;
        for (int k = 0; k < startsSchedules[i].size(); k++) {
          StartsSchedule tmpSchedule = (StartsSchedule) starts.elementAt(k);
          if (aSchedule.getEmployee() < tmpSchedule.getEmployee()) {
            startsSchedules[i].insertElementAt(aSchedule, k);
            inserted = true;
            break;
          }
        }
        if (!inserted) {
          startsSchedules[i].add(aSchedule);
        }
      }
    }
  }

  private Hashtable startsGroupedByEmployee = new Hashtable();

  private void groupStartsByEmployee() {
    Vector[] startsSchedules = schedulesGroupedByBucket;
    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);
        int employeeID = aSchedule.getEmployee();
        String key = new Integer(employeeID).toString();
        Vector vec = (Vector) startsGroupedByEmployee.get(key);
        if (null == vec) {
          vec = new Vector();
          startsGroupedByEmployee.put(key, vec);
        }
        vec.add(aSchedule);
      }
    }
  }

  private void assignEquipmentSimple() {
    Enumeration allKeys = startsGroupedByEmployee.keys();
    EquipmentCapabilityTable ect = EquipmentCapabilityTable.getInstance();

    while (allKeys.hasMoreElements()) {
      String key = (String) allKeys.nextElement();

      Vector vec = (Vector) startsGroupedByEmployee.get(key);

      StartsSchedule aSchedule = (StartsSchedule) vec.elementAt(0);
      ect.getEquipmentSimple(aSchedule);
      String equipmentID = aSchedule.getEquipment();
      for (int i = 1; i < vec.size(); i++) {
        StartsSchedule tmpSchedule = (StartsSchedule) vec.elementAt(i);
        tmpSchedule.setEquipment(equipmentID);
      }
    }
  }

  private void assignEquipment() {
    Vector[] startsSchedules = schedulesGroupedByBucket;
    //Vector[] startsSchedules = ProductionStartsSchedule.getInstance().getStartsSchedules();
    EquipmentCapabilityTable ect = EquipmentCapabilityTable.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);
        int status = ect.getEquipment(aSchedule);
        if (status < 0) {
          aSchedule.setEquipment("-1");
        }
      }
    }

  }

  private void assignEquipment2() {
    Vector[] startsSchedules = schedulesGroupedByBucket;
    EquipmentCapabilityTable ect = EquipmentCapabilityTable.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);
        if (!aSchedule.getEquipment().equals("-1"))
          continue;

        ect.getEquipment2(aSchedule);
      }
    }

  }

  private void assignStartEndTime() {
    //Vector[] startsSchedules = ProductionStartsSchedule.getInstance().getStartsSchedules();
    Vector[] startsSchedules = schedulesGroupedByBucket;
    PeriodDateMap pdm = PeriodDateMap.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);
        int bucketID = aSchedule.getBucketID();
        aSchedule.setTimeInterval(pdm.getStartingTime(bucketID),
                                  pdm.getEndingTime(bucketID));
      }
    }

  }

  private Vector[] startsByRoute = new Vector[DataModel.getInstance().getRoutes().
      getNumberOfRoutes()];
  int totalMinutes = 0;
  private void groupScheduleByRoute() {
    Vector[] startsByBucket = schedulesGroupedByBucket;

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

      for (int j = 0; j < starts.size(); j++) {
        StartsSchedule aSchedule = (StartsSchedule) starts.elementAt(j);
        totalMinutes += aSchedule.getDurationInMinutes();
        if (null == startsByRoute[aSchedule.getRouteID() - 1]) {
          startsByRoute[aSchedule.getRouteID() - 1] = new Vector();
        }
        startsByRoute[aSchedule.getRouteID() - 1].add(aSchedule);
      }
    }

  }

  private void createSummaryReport() {
    ProductDemands prodDmds = DataModel.getInstance().getProductDemands();
    Hashtable lastRoutes = prodDmds.getLastRoutes();
    Enumeration allLastRoutes = lastRoutes.elements();
    Vector styles = OrderDetailsManHourMap.getInstance().getAllStyles();
    Date catchUpDate = new Date(PeriodDateMap.getInstance().getLastBucketDate().
                                getTime() +
                                7 * 24 * 60 * 60 * 1000);