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 com.power.pipeengine.Entity.*;
import com.power.pipeengine.InputData.*;
import com.power.pipeengine.DispatchReportMap.*;
import java.util.*;
import java.text.*;

public class StartsSchedule {
    private int bucketID;
    private int rteID;
    private double starts;

    private String orderID;
    private String styleID;
    private int pid;
    private int qty;
    private int pidNext;
    private double stdProcTime;

    private Date startTime;
    private Date endTime;

    private String assignedEquipment;
    private int assignedEmployee = -1;

    private StartsSchedule parent;

    private double capIdx = 1.0;

    private int actualStartTime = 0;
    private int duration = 0;

    private boolean useNextDayCap = false;
    private double nextDayCapUsed = 0.0;

    private boolean assigned = false;

    private boolean isSplited = false;

    private int lineNumber = 0;

    public StartsSchedule( int b, int r, double val ) {
        bucketID = b;
        rteID = r;
        starts = val;
    }

    public void reviseStarts( double aDbl ) {
        starts = aDbl;
    }

    public void setSplited() {
        isSplited = true;
    }

    public boolean isSplited() {
        return isSplited;
    }

    public StartsSchedule getSplitedSchedule( int anInt) {
        StartsSchedule aSchedule = new StartsSchedule( bucketID, rteID, anInt );
        aSchedule.processStyle( new Style(
                new Integer( rteID ),
                orderID,
                styleID,
                new Integer( pid ),
                new Integer( pidNext ),
                new Integer ( anInt ) ,
                new Double( stdProcTime) ), anInt );
        aSchedule.setSplited();

        qty -= anInt;

        aSchedule.setEquipment( assignedEquipment );
        aSchedule.setParent( parent );
        return aSchedule;
    }

    public int getAssignedEmployee() {
        return assignedEmployee;
    }

    public String getOrderID() {
        return orderID;
    }

    public String getStyleID() {
        return styleID;
    }

    public int getProcessID() {
        return pid;
    }
    public int getBucketID() {
        return bucketID;
    }

    public int getRouteID() {
        return rteID;
    }

    public double getStartsValue() {
        return starts;
    }

    public void augmentStarts() {
        starts += 1.0;
    }

    public void augmentQuantity( int q ) {
        qty += q;
    }

    public void adjustStartsForMultiSrcingProducts( int numOfSrcs ) {
      starts *= numOfSrcs;
    }

    public void integrizeStarts() {
        starts = Math.floor( starts );
    }

    public void modifyBucketID( int newBucketID ) {
      bucketID = newBucketID;
    }

    public void processStyle( Style aStyle, int q ) {
        orderID = aStyle.getOrderID();
        styleID = aStyle.getStyleID();
        pid = aStyle.getProcessID();
        pidNext = aStyle.getNextProcessID();
        stdProcTime = aStyle.getProcessingTime();
        qty = q;
        adjustedCap = qty;
    }

    public StartsSchedule getExtraCapacity() {
        return new StartsSchedule( bucketID, rteID, (starts - qty) );
    }

    public void setStartTime( Date aDate ) {
        startTime = aDate;

    }

    public int getNextPID() {
        return pidNext;
    }

    public void setEndTime( Date eTime ) {
        endTime = new Date( startTime.getTime() +
                            (long) ( qty * stdProcTime / capIdx ) * 60 * 1000 );
    }

    public void setTimeInterval( Date sTime, Date eTime ) {
        Calendar cal = Calendar.getInstance();
        cal.setTime( sTime );
        cal.set( Calendar.HOUR_OF_DAY, 0 );
        cal.set( Calendar.MINUTE, 0 );
        cal.set( Calendar.SECOND, 0 );
        Date zeroHours = cal.getTime();
        Vector bucketsInDate = PeriodDateMap.getInstance().getPeriodsInDate( zeroHours );
        startTime = new Date( sTime.getTime() + (long) actualStartTime * 60 * 1000 );
        endTime = new Date( sTime.getTime() + (long) (actualStartTime + duration) * 60 * 1000 );
        double noonStartingTime = WorkingHours.getInstance().getAMStartTime() + 4;
        cal.set( Calendar.HOUR_OF_DAY, (int) Math.floor( noonStartingTime ) );
        cal.set( Calendar.MINUTE, (int) ( noonStartingTime * 60 - 60 * Math.floor( noonStartingTime) ) );
        Date noon = cal.getTime();
        double dinnerStartingTime = WorkingHours.getInstance().getPMStartTime() + 4;
        cal.set( Calendar.HOUR_OF_DAY, (int) Math.floor( dinnerStartingTime ) );
        cal.set( Calendar.MINUTE, (int) ( dinnerStartingTime * 60 - 60 * Math.floor( dinnerStartingTime) ) );
        Date dinnerTime = cal.getTime();
        double amStartingTime = WorkingHours.getInstance().getAMStartTime();
        cal.set( Calendar.HOUR_OF_DAY, (int) Math.floor( amStartingTime ) );
        cal.set( Calendar.MINUTE, (int) ( amStartingTime * 60 - 60 * Math.floor( amStartingTime) ) );
        Date eightOClock = cal.getTime();

        long oneHour = 60 * 60 * 1000;
        long lunchBreak = (long) ( oneHour * WorkingHours.getInstance().getLunchBreakLenght() );
        long dinnerBreak = (long) ( oneHour * WorkingHours.getInstance().getDinnerBreakLength() );
        if( bucketsInDate.size() == 1 ) {
            if( !startTime.before( noon ) ) {
                startTime.setTime( startTime.getTime() + lunchBreak );
            }
            if( endTime.after( noon ) ) {
                endTime.setTime( endTime.getTime() + lunchBreak ); //one hour lunch break
            }

            if( !startTime.before( dinnerTime ) ) {
                startTime.setTime( startTime.getTime() + dinnerBreak );
            }
            if( endTime.after( dinnerTime ) ) {
                endTime.setTime( endTime.getTime() + dinnerBreak ); //one hour dinner break
            }
        } else {
            if( !startTime.after( noon ) && endTime.after( noon ) ) {
                if( startTime.equals( noon ) ) {
                    startTime.setTime( startTime.getTime() + lunchBreak );
                }
                endTime.setTime( endTime.getTime() + lunchBreak ); //one hour lunch break
            }

            if( !startTime.after( dinnerTime ) && endTime.after( dinnerTime ) ) {
                if( startTime.equals( dinnerTime ) ) {
                    startTime.setTime( startTime.getTime() + dinnerBreak );
                }
                endTime.setTime( endTime.getTime() + dinnerBreak ); //one hour lunch break
            }
        }

        if( useNextDayCap ) {
            endTime.setTime( eightOClock.getTime() + (long) ( (24 + nextDayCapUsed) * 60 * 60 * 1000 ) );
        }

    }

    public void setEquipment( String equipment ) {
        assignedEquipment = equipment;
    }

    public String getEquipment() {
        return assignedEquipment;
    }

    public void setParent( StartsSchedule aSchedule ) {
        parent = aSchedule;
    }

    public StartsSchedule getParent() {
        return parent;
    }

    public void printOrigSchedule() {
        System.out.println( rteID + ", " +
                            bucketID + ", " +
                            starts );

    }

    public String getSchedule() {
        SimpleDateFormat sdf = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );

        if( qty == 0 ) {
            return "";
        }

        if( null == orderID || null == styleID ) {
            return "";
        }

        String nextOp = "";
        for( int i=0; i<nextOpLineNum.size(); i++ ) {
            nextOp += "," + ((Integer) nextOpLineNum.elementAt( i )).toString();
        }

        int lineNumOffset = DispatchList.getInstance().getMaxAutoIDInDispatchList();
        int lineNum = lineNumOffset + this.getLineNumber();

        return assignedEquipment + "," +
                orderID + "," +
                styleID + "," +
                pid + "," +
 //               pidNext + "," +
                assignedEmployee + "," +
                qty + "," +
                0 + "," +
                sdf.format( startTime ) + "," +
                sdf.format( endTime ) + "," +
                "null," + lineNum + "\n";

    }

    public String getScheduleTest() {
        SimpleDateFormat sdf = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );

        if( qty == 0 ) {
            return "";
        }

        if( null == orderID || null == styleID ) {
            return "";
        }


        int lineNumOffset = DispatchList.getInstance().getMaxAutoIDInDispatchList();
        int lineNum = lineNumOffset + this.getLineNumber();

        return assignedEquipment + "," +
                orderID + "," +
                styleID + "," +
                pid + "," +
                pidNext + "," +
                assignedEmployee + "," +
                qty + "," +
                0 + "," +
                sdf.format( startTime ) + "," +
                sdf.format( endTime ) + "," +
                "null," + lineNum + "\n";

    }
    public void setEmployee( int anID, double capIndex ) {
        assignedEmployee = anID;
        capIdx = capIndex;
    }

    public int getQuantity() {
        return qty;
    }

    String type = "N";

    public void setType( String aType ) {
      type = aType;
    }

    public String getType() {
      return type;
    }

    public double getStandardProcessingTime() {
        return stdProcTime;
    }

    public void setActualStartTime( int t ) {
        actualStartTime = t;
    }

    public int getActualStartTime() {
        return actualStartTime;
    }

    public void setDuration( int t ) {
        duration = t;
    }

    public double getRequiredStdTimeInHours() {
        return qty * stdProcTime / 60.0;
    }

    public double getDurationInMinutes() {
        return duration;
    }

    public boolean useCapInNextDay() {
        return useNextDayCap;
    }

    public void setNextDayCapUseFlag( boolean aFlag ) {
        useNextDayCap = aFlag;
    }

    public double getNextDayCapUsed() {
        return nextDayCapUsed;
    }

    public void setNextDayCapUsed( double aDbl ) {
        nextDayCapUsed = aDbl;
    }

    public Date getStartTime() {
        return startTime;
    }

    public Date getEndTime() {
        return endTime;
    }

    public void setAssignedStatus( boolean status ) {
        assigned = status;
    }

    public boolean isAssigned() {
        return assigned;
    }

    private Vector operatorID = new Vector();
    private Vector quantities = new Vector();
    private Vector processIDs = new Vector();

    public void addNextOperator( int operator, int numOfPieces, int procID ) {
        operatorID.add( new Integer(operator) );
        quantities.add( new Integer( numOfPieces ) );
        processIDs.add( new Integer( procID ) );
    }

    int usedCap = 0;
    int adjustedCap = 0;
    public void setAdjustedCap( int cnt ) {
        adjustedCap = cnt * qty;
    }

    public int getRemainingCap() {
        return adjustedCap - usedCap;
    }

    public void updateUsage( int num ) {
        usedCap += num;
    }

    public void initPrevRoutes() {
      prevRoutes = DataModel.getInstance().getRoutes().getRoute( rteID ).getPrevRoutes();
      remainingCap = qty;
      initRemainingCapTbl();
    }

    private Vector prevRoutes = null;
    Hashtable remainingCapTbl = new Hashtable();
    private void initRemainingCapTbl() {
      if( null == prevRoutes || prevRoutes.size() <= 1 ) return;
      for( int i=0; i<prevRoutes.size(); i++ ) {
        Route route = (Route) prevRoutes.elementAt( i );
        remainingCapTbl.put( new Integer( route.getRouteID() ), new Integer( qty ) );
      }
    }

    int remainingCap = qty;
    public int getRemainingCap( int routeID ) {
      if(  null == prevRoutes || prevRoutes.size() <= 1 ) return remainingCap;
      if( null == remainingCapTbl.get( new Integer(routeID) )) {
        return remainingCap;
      }
      return ((Integer) remainingCapTbl.get( new Integer(routeID) )).intValue();
    }

    public void updateUsage( int routeID, int num ) {
      if(  null == prevRoutes || prevRoutes.size() <= 1 ) {
        remainingCap -= num;
        return;
      }
      if( null == remainingCapTbl.get( new Integer(routeID) )) {
        remainingCap -= num;
        return;
      }
      int remCap = ((Integer) remainingCapTbl.get( new Integer(routeID) )).intValue();
      remCap -= num;
      remainingCapTbl.put(  new Integer(routeID), new Integer( remCap) );
    }

    public int getEmployee() {
        return assignedEmployee;
    }

    public void setLineNumber( int n ) {
        lineNumber = n;
    }

    public int getLineNumber() {
        return lineNumber;
    }

    private Vector nextOpLineNum = new Vector();
    public void addNextOpLineNumber( int num ) {
        nextOpLineNum.add( new Integer(num) );
    }

    public Vector getNextOpLineNumber() {
        return nextOpLineNum;
    }

    public String getNextOperators( int offset) {
        String str = new String();
        for( int i=0; i<nextOpLineNum.size(); i++ ) {
            str += ( getLineNumber() + offset ) + ",";
            int nextLineNum = ((Integer) nextOpLineNum.elementAt( i )).intValue() + offset;
            str +=  nextLineNum + ",";
            str += (Integer) quantities.elementAt( i ) + ",0" + "\n";
        }
        return str;
    }

    public void setDefaultTimeInterval() {
        this.setStartTime( PeriodDateMap.getInstance().getStartingTime( bucketID ));
        endTime = new Date( startTime.getTime() +
                            (long) (starts * stdProcTime) * 60 * 1000 );
    }
}