import java.util.ArrayList;
import java.util.LinkedList;
import java.util.TreeMap;

/**
 * Created by abhinavkishore on 23/10/14.
 */
public class Edge {

    private Node node;
    private int propDelay;
    private int connectionCap;
    private int numCurrConnections;
    private ArrayList<Float> startTimes;
    private ArrayList<Float> endTimes;
    private TreeMap<Float, Integer> startHash;
    private TreeMap<Float, Integer> endHash;
    private TreeMap<Float, LinkedList<Float>> endToStartHash;


    public Edge(Node node, int propDelay, int connectionCap){
        this.node = node;
        this.propDelay = propDelay;
        this.connectionCap = connectionCap;
        this.numCurrConnections = 0;
        this.startTimes = new ArrayList<Float>();
        this.endTimes = new ArrayList<Float>();
        this.startHash = new TreeMap<Float, Integer>();
        this.endHash = new TreeMap<Float, Integer>();
        this.endToStartHash = new TreeMap<Float, LinkedList<Float>>();
    }

    public Node getNode(){
        return this.node;
    }

    public int getPropDelay() {
        return propDelay;
    }

    public int getConnectionCap() {
        return connectionCap;
    }

    public int getNumCurrConnections(){
        return this.numCurrConnections;
    }

    public boolean updateConnection(int update){
//        System.out.println(" Curr Connections = " + numCurrConnections + " Max connections = " + this.connectionCap);
        if(numCurrConnections == connectionCap && update == 1){
//            System.out.println("MAXED OUT");
            return false;
        }
        this.numCurrConnections += update;
        return true;
    }

    public boolean hasConnection(int update){
        if(numCurrConnections == connectionCap && update == 1){
            return false;
        }
        return true;
    }


    public void clearCap(Float startTime){

//        System.out.println("Before : " + endToStartHash.toString());

        LinkedList<Float> toBeRemoved = new LinkedList<Float>();
        for(Float key: endHash.keySet()){
            if(startTime >= key){
                toBeRemoved.add(key);
                removeFromHash(endToStartHash.get(key), 0); //0 is startHash
                endToStartHash.remove(key);
            } else {
                break;
            }
        }
        removeFromHash(toBeRemoved, 1);

//        System.out.println("Should have removed " + toBeRemoved.toString());

//        System.out.println("After : " + endToStartHash.toString());

    }

    private void removeFromHash(LinkedList<Float> toBeRemoved, int hashNum) {
        TreeMap<Float, Integer> hash = startHash;
        if(hashNum == 1){
            hash = endHash;
        }

        if(toBeRemoved == null){
            return;
        }

//        System.out.println("ToBeRemoved: " + toBeRemoved.toString());
//        System.out.println("Hash: " + hash);

        for(int i = 0; i < toBeRemoved.size(); i++){
            Float key = toBeRemoved.get(i);
            int val = hash.get(key);
            if(val - 1 == 0){
                hash.remove(key);
            } else {
                hash.put(key, val - 1);
            }
        }
    }

    public void updateTimes(Float startTime, Float endTime){

//        System.out.println("Updating start time: "+ startTime);
        int val = 0;
        if(startHash.containsKey(startTime)){
            val = startHash.get(startTime);
        }
        startHash.put(startTime, val + 1);

        val = 0;
        if(endHash.containsKey(endTime)){
            val = endHash.get(endTime);
        }
        endHash.put(endTime, val + 1);

        LinkedList<Float> addToHash = new LinkedList<Float>();
        if(endToStartHash.containsKey(endTime)){
            addToHash = endToStartHash.get(endTime);
        }
        addToHash.add(startTime);
        endToStartHash.put(endTime, addToHash);

    }

    public int getCapacity(Float endTime, Float startTime){
//        endTime = new Float(20);
        Float currTime = new Float(0.0);
        int i = 0;
        int j = 0;
        int currCapacity = 0;

        System.out.println("Start Hash: "+ startHash.toString());
        System.out.println("End Hash: "+ endHash.toString());

//        float[] startKeys = new float[] {1, 2, 10, 20, 30};
//        float[] endKeys = new float[] {7, 8, 11, 21, 35};

        Object[] startKeys = startHash.keySet().toArray();
        Object[] endKeys = endHash.keySet().toArray();

//       System.out.println(endToStartHash.toString());

        Float currStartTime;
        Float currEndTime;

        if(startKeys.length > 0){
//            currStartTime = startKeys[0];
//            currEndTime = endKeys[0];
            currStartTime = (Float) startKeys[0];
            currEndTime = (Float) endKeys[0];
//            i++;
//            System.out.print("StartHash: ");
//            for(int k = 0; k < startKeys.length; k++){
//                System.out.print((Float) startKeys[k] + " ");
//            }
//
//            System.out.print("EndHash: ");
//            for(int k = 0; k < endKeys.length; k++){
//                System.out.print((Float) endKeys[k] + " ");
//            }
//            System.out.println();
        } else {
//            System.out.println("entered");
            return 0;
        }

//        System.out.println("Sizes are " + endKeys.length);
        int maxCap = 0;
        int type = 0;
        boolean isMaxCap = false;

//        System.out.println("currTime: " + currTime);
//        System.out.println("endTime: " + endTime);

        while(currTime.compareTo(endTime) == -1 && (i < startKeys.length || j < endKeys.length)){
//            System.out.println("currStartTime: " + currStartTime);
//            System.out.println("currEndTime: " + currEndTime);
//            System.out.println("i: " + i);
//            boolean condi = i < startKeys.length;
//            System.out.println("Condition: " + condi);
            if(currStartTime.compareTo(currEndTime) == -1 && i < startKeys.length){

                currTime = currStartTime;
                currCapacity += startHash.get(currTime);
//                System.out.print(startHash.get(currTime) + " PLUS for " + currTime);
                i++;
                type = 1;

            } else if(j < endKeys.length){

                currTime = currEndTime;
                currCapacity -= endHash.get(currTime);
//                System.out.println(" " + endHash.get(currTime) + " MINUS for " + currTime);
                j++;
                type = 2;
            }

            if(isMaxCap || type == 2 && currTime >= startTime) {
                isMaxCap = true;
                maxCap = Math.max(maxCap, currCapacity);
            }


            if(i < startKeys.length){
                currStartTime = (Float) startKeys[i];
            }

            if(j < endKeys.length){
                currEndTime = (Float) endKeys[j];
            }
        }
//
//        if(currCapacity == 1){
//            maxCap = Math.max(maxCap, currCapacity);
//        }
//        if(currTime.equals(endTime)){
//            maxCap --;
//        }
        System.out.println("Current time is: " + currTime + " End time is: +" + endTime + " maxCap: "+ maxCap);

//        System.out.println("Capacity: " + currCapacity);

        return maxCap;
    }


}