package com.power.pipeengine.DispatchReportMap;

import java.util.*;
import java.io.*;
import java.text.*;
import java.net.*;

import com.power.util.Message.*;
import com.power.pipeengine.Entity.*;
import com.power.pipe.*;
import com.power.util.Message.*;
import com.power.pipeengine.*;
import com.power.pipeengine.InputData.*;
import com.power.pipeengine.DispatchReport.*;

public class ProcessCapabilityTable
    extends InputReader {
  static ResourceBundle res = ResourceBundle.getBundle(
      "com.power.pipeengine.Res",
      EngineConfig.getInstance().getLocale());
  private Hashtable processCapabilityTable = new Hashtable();
  private Hashtable capTblByEmployee = new Hashtable();
  private String _fileName = "processcapability";

  private static final ProcessCapabilityTable INSTANCE =
      new ProcessCapabilityTable();

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

  public static ProcessCapabilityTable getInstance() {
    return INSTANCE;
  }

  protected String getFileName() {
    return _fileName;
  }

  public Hashtable getProcessCapabilityTable() {
    return processCapabilityTable;
  }

  public int getNumOfOperatorsForRoute( Integer rteID ) {
    return ((Vector) processCapabilityTable.get( rteID )).size();
  }

  public void markUnavailable(Integer employeeID, int bucketID) {
    ProcessCapability pc = (ProcessCapability) capTblByEmployee.get(employeeID);
    if (null == pc)
      return;
    pc.turnOffBucket(bucketID);
  }

  public Vector getCapableOperators( int pid ) {
    return (Vector) processCapabilityTable.get(new Integer(pid) );
  }

  public double getTotalCapability( int pid ) {
    Vector vec = (Vector) processCapabilityTable.get(new Integer(pid) );
    double total = 0;
    for( int i=0; i<vec.size(); i++ ) {
      ProcessCapability pc = (ProcessCapability) vec.elementAt( i );
      if( pc.getAssignedPID() != 0 && pc.getAssignedPID() != pid ) continue;
      total += pc.getCapability( pid );
    }
    return total;
  }

  public int getEmployee(StartsSchedule aSchedule) {
    Vector pb = (Vector) processCapabilityTable.get(new Integer(aSchedule.
        getProcessID()));

    if (null == pb) {
      aSchedule.setDefaultTimeInterval();
      return -1;
    }

    for (int i = 0; i < pb.size(); i++) {
      ProcessCapability aProcCap = (ProcessCapability) pb.elementAt(i);
      if (aProcCap.mayAssignToSchedule(aSchedule)) {
        int rtn = aProcCap.assignToSchedule(aSchedule);
        return rtn;
      }
    }

    //aSchedule.setDefaultTimeInterval();
    return -10000;
  }

  private void addProcCap(Vector vec, ProcessCapability cp, int pid) {
    if (null == vec) {
      return;
    }

    //simply append.
    vec.add(cp);

    /*for (int i = 0; i < vec.size(); i++) {
      ProcessCapability tmpPC = (ProcessCapability) vec.elementAt(i);
      if (cp.getCapability(pid) > tmpPC.getCapability(pid)) {
        vec.insertElementAt(cp, i);
        return;
      }
    }

    vec.add(cp);*/
  }

  Vector allProcs = new Vector();

  private void insertNewProcess( Integer pid ) {
    for( int i=0; i<allProcs.size(); i++ ) {
      Integer anInt = (Integer) allProcs.elementAt( i );
      if( anInt.intValue() == pid.intValue() ) return;
    }
    allProcs.add( pid );
  }

  public void readData() throws Exception {
    BufferedReader d = super.getReader();

    if (null == d) {
      return;
    }

    String token = GlobalConfig.getInstance().getSeparator();
    String aLine = d.readLine();

    while (aLine != null) {
      if (aLine.length() <= 1) {
        aLine = d.readLine();
        continue;
      }
      StringTokenizer st = new StringTokenizer(aLine, token);
      if (st.countTokens() < 3) {
        MessageArea.getInstance().addMessage("File " + getFileName() +
                                             " reading error: " +
                                             "Insufficient number of columns: " +
                                             st.countTokens() + " found; " +
                                             " 3 required\n");
      }

      Integer routeID = new Integer(st.nextToken());
      Integer employeeID = new Integer(st.nextToken());
      Double capIndex = new Double(st.nextToken());

      insertNewProcess( routeID );

      Vector tmpVec = (Vector) processCapabilityTable.get(routeID);
      if (null == tmpVec) {
        tmpVec = new Vector();
        processCapabilityTable.put(routeID, tmpVec);
      }

      ProcessCapability pc = (ProcessCapability) capTblByEmployee.get(
          employeeID);

      if (null == pc) {
        pc = new ProcessCapability(employeeID.intValue());
        pc.addCapability(routeID, capIndex);
        capTblByEmployee.put(employeeID, pc);
        //tmpVec.add( pc );
        addProcCap(tmpVec, pc, routeID.intValue());
        pc.setCapInBuckets(PeriodDateMap.getInstance().getCopyOfHoursInBuckets());
      }
      else {
        pc.addCapability(routeID, capIndex);
        if (!tmpVec.contains(pc)) {
          //tmpVec.add( pc );
          addProcCap(tmpVec, pc, routeID.intValue());
        }
      }

      aLine = d.readLine();
    }

    d.close();
    super.closeURLConnection();

    preAssignCriticalRsc();

  }

  private void preAssignCriticalRsc() {
    for( int i=0; i<allProcs.size(); i++ ) {
      Integer pid = (Integer) allProcs.elementAt( i );
      Vector capTbl = this.getCapableOperators( pid.intValue() );
      if( capTbl.size() == 1 ) {
        ProcessCapability pc = (ProcessCapability) capTbl.firstElement();
        pc.setAssignedPID( pid.intValue() );
      }
    }
  }

  public void resortRouteCap( int pid, ProcessCapability pc ) {
    Hashtable capTable = pc.getCapTable();
    if( null == capTable || capTable.size() == 0 ) return;
    Enumeration capKeys = capTable.keys();

    while( capKeys.hasMoreElements() ) {
      Integer procID = (Integer) capKeys.nextElement();
      if( procID.intValue() == pid ) continue;
      Vector procCapTbl = (Vector) processCapabilityTable.get( procID );
      if( null == procCapTbl ) continue;
      procCapTbl.remove( pc );
      procCapTbl.add( pc );
    }
  }

  private void print() {

    for (int k = 1; k < 40; k++) {
      Vector tmpVec = (Vector) processCapabilityTable.get(new Integer(k));
      if (null == tmpVec)
        continue;
      for (int i = 0; i < tmpVec.size(); i++) {
        ProcessCapability pc = (ProcessCapability) tmpVec.elementAt(i);
        pc.print(k);
      }
    }
  }

}