package NetLayout;

import java.util.*; // for StringTokenizer and Vector
import java.io.*;
import java.awt.Point;


public class Net {
  final static int CLIENT = 1;
  final static int SERVER = 2;
  final static int CACHE = 3;
  final static int DNS = 4;
  final static int LBA = 5;
  final static int ROUTER = 6;
  final static int SWITCH = 7;
  final static int NoOfNodeTypes = 7;
  final static int PTPLINK = 8;
  final static int MALINK = 9;
  final static int CABLE = 10;
  final static int NoOfObjects = 10;
  final static int NOTFOUND = -2;
  final static int NOTDEFINED = -1;
  String name = "net1";
  NetLayoutFrame f;
  int[] objNo = new int[NoOfObjects+1];
  int objID = 0;
  Vector nodes = new Vector(10, 10);
  Vector routers = new Vector(10, 10);
  Vector switches = new Vector(10, 10);
  Vector links = new Vector(10, 10);
  Vector malinks = new Vector(10, 10);

  ComponentDelayList cdl = new ComponentDelayList(this);

  int[][] pred;
  int[][] dist;
  int[][] sp_dist;
  EventList el;
  EventRecord er;
  double msgProcessingTime = 0.0001; // for power=1 unit 0.1msec, related to msgheader
  double retrieveSpeed = 1.0E+6;     // 1MBps file retrieval
  double msgProcessingSpeed = 1.0E+6;  // 1MBps for power=1 unit, relate to msgSize
  double signalPropagationSpeed = 2.0E+8; // use fiber propagation speed here
  int reqID = 0;
  double totalEndToEndRespTime = 0;
  int noOfFinishedRequests = 0;
  int noOfDocs = 1000000; // use for generate doc index at client site
  DataOutputStream debugOS;
  PrintWriter logPW;
  boolean debug = false;
  boolean verbose = false;
  public boolean animationOn = true;
  public int animationMaxSteps = 20;  // thing to adjust in animation speed
                                      // here we divide propagation deley with this
  public Net() {
  }
  public Net(NetLayoutFrame frame, String name) {
    f=frame;
    this.name = name;
  }
  public void addComponentDelay(int id) {
    cdl.addComponentDelay(id);
  }
  public void addComponentDelayList(ComponentDelayList list) {
    // accumulate delay on each network component from the list
    // add ranking to give each session a fair contribution
    for (int j=0; j<list.v.size(); j++) {
      ComponentDelay cd = (ComponentDelay) list.v.elementAt(j);
      boolean flag = true;
      for (int i=0; flag && i<cdl.v.size(); i++) {
        ComponentDelay cdi = (ComponentDelay) cdl.v.elementAt(i);
        if (cdi.ID == cd.ID) {
          // merge the delays
          cdi.queueingTime += cd.queueingTime;
          cdi.msgProcessingTime += cd.msgProcessingTime;
          cdi.propagationTime += cd.propagationTime;
          cdi.transmissionTime += cd.transmissionTime;
          cdi.retrieveTime += cd.retrieveTime;
          // need to recompute totalDelay
          cdi.computeTotalDelay();
          cdi.rank += cd.rank;
          flag = false; // check if break exit only inner loop
        }
      }
    }
  }
  public void animate(EventRecord er, double time, double propagationTime,
                      int p1x, int p1y, int p2x, int p2y) {
    EventRecord animateER = er.copy();
    double deltaTime = propagationTime/(animationMaxSteps+1);
    animateER.time = time+deltaTime;  // first animate event
    animateER.addField("p1x", ""+p1x);
    animateER.addField("p1y", ""+p1y);
    animateER.addField("p2x", ""+p2x);
    animateER.addField("p2y", ""+p2y);
    animateER.addField("deltaTime", ""+deltaTime);
    animateER.addField("step", ""+0);
    animateER.setNext(-2);  // -2 for animator; it is the receiver of the event
    el.queueEvent(animateER);
  }
  public void setAnimationOn(boolean flag) {
    animationOn = flag;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getName() {
    return name;
  }
  public int getReqID() {
    return reqID++;
  }
  int getID(String name) {
    if (name.length() == 0) return NOTDEFINED; 
    int cmp = name.compareTo("null");
    if (cmp == 0) return NOTDEFINED; // not defined
    int size = nodes.size();
    for (int i=0; i<size; i++) {
      Node node = (Node) nodes.elementAt(i);
      cmp = name.compareTo(node.name);
      if (cmp == 0) return node.ID;
    }
    return NOTFOUND; // not found
  }
  public String getNameWithID(int ID) {
    Node n = searchNode(ID);
    if (n != null) return n.name;
    Cable c = searchCable(ID);
    if (c != null) return c.name;
    PTPLink p = searchPTPLink(ID);
    if (p != null) return p.name;
    logPrintln("ID="+ID+" not found in node, cable and PTPLinnk list");
    return null;

  }
  Node searchNode(int ID) {
    int size = nodes.size();
    for (int i=0; i<size; i++) {
      Node node = (Node) nodes.elementAt(i);
      if (node.ID == ID) return node;
    }
    return null;
  }
  Client searchClient(int ID) {
    int size = nodes.size();
    for (int i=0; i<size; i++) {
      Node cl = (Node) nodes.elementAt(i);
      if (cl.ID == ID && cl.type == CLIENT) return (Client) cl;
    }
    return null;
  }
  Server searchServer(int ID) {
    int size = nodes.size();
    for (int i=0; i<size; i++) {
      // Server s = (Server) nodes.elementAt(i);
      // cause runtime typecast error, since some nodes are not servrs
      Node s = (Node) nodes.elementAt(i);
      if (s.ID == ID && s.type == SERVER) return (Server) s;
    }
    return null;
  }
  CacheServer searchCacheServer(int ID) {
    int size = nodes.size();
    for (int i=0; i<size; i++) {
      Node s = (Node) nodes.elementAt(i);
      if (s.ID == ID && s.type == CACHE) return (CacheServer) s;
    }
    return null;
  }
  DNS searchDNS(int ID) {
    int size = nodes.size();
    for (int i=0; i<size; i++) {
      Node s = (Node) nodes.elementAt(i);
      if (s.ID == ID && s.type == DNS) return (DNS) s;
    }
    return null;
  }
  LBA searchLBA(int ID) {
    int size = nodes.size();
    for (int i=0; i<size; i++) {
      Node s = (Node) nodes.elementAt(i);
      if (s.ID == ID&& s.type == LBA) return (LBA) s;
    }
    return null;
  }
  Router searchRouter(int ID) {
    int size = routers.size();
    for (int i=0; i<size; i++) {
      Router s = (Router) routers.elementAt(i);
      if (s.ID == ID) return s;
    }
    return null;
  }
  Switch searchSwitch(int ID) {
    int size = switches.size();
    for (int i=0; i<size; i++) {
      Switch s = (Switch) switches.elementAt(i);
      if (s.ID == ID) return s;
    }
    return null;
  }
  Node searchNode(int x, int y) {
    int size = nodes.size();
    for (int i=0; i<size; i++) {
      Node node = (Node) nodes.elementAt(i);
      if (node.inNode(x,y)) {
          f.statusBar.setText("found "+node.getName()+ ", x="+node.getX()+", y="+node.getY());
          return node;
        }
    }
    f.statusBar.setText("No node in this location.");
    return null;
  }
  
  Router searchRouter(int x, int y) {
    int size = routers.size();
    for (int i=0; i<size; i++) {
      Router r = (Router) routers.elementAt(i);
      if (r.inNode(x,y)) {
        f.statusBar.setText("Router found "+r.getName()+ ", x="+
          r.getX()+", y="+r.getY());
        return r;
      }
    }
    f.statusBar.setText("No Router in this location.");
    return null;
  }
  Switch searchSwitch(int x, int y) {
    int size = switches.size();
    for (int i=0; i<size; i++) {
      Switch sw = (Switch) switches.elementAt(i);
      if (sw.inNode(x,y)) {
        f.statusBar.setText("Switch found "+sw.getName()+ ", x="+
            sw.getX()+", y="+sw.getY());
        return sw;
      }
    }
    f.statusBar.setText("No Switch in this location.");
    return null;
  }
  MALink searchMALink(int ID) {
    for (int i=0; i<malinks.size(); i++) {
      MALink link = (MALink) malinks.elementAt(i);
      if (link.ID == ID) {
        // System.out.println("found "+link.getName());
        return link;
      }
    }
    return null;
  }
  MALink searchMALink(int x, int y) {
    for (int i=0; i<malinks.size(); i++) {
      MALink link = (MALink) malinks.elementAt(i);
      if (link.inLink(x, y)) {
        // f.statusBar.setText("found "+link.getName());
        return link;
      }
    }
    return null;
  }
  Cable searchCable(int x, int y) {
    for (int i=0; i<links.size(); i++) {
      Link link = (Link) links.elementAt(i);
      if (link.type == CABLE && link.inLink(x, y)) return (Cable) link;
    }
    return null;
  }
  PTPLink searchPTPLink(int x, int y) {
    for (int i=0; i<links.size(); i++) {
      Link link = (Link) links.elementAt(i);
      if (link.type == PTPLINK && link.inLink(x, y)) return (PTPLink) link;
    }
    return null;
  }
  Link searchLink(int x, int y) {
    for (int i=0; i<links.size(); i++) {
      Link link = (Link) links.elementAt(i);
      if (link.inLink(x, y)) return link;
    }
    return null;
  }
  Cable searchCable(int ID) {
    for (int i=0; i<links.size(); i++) {
      Link link = (Link) links.elementAt(i);
      if (ID == link.getID() && link.type == CABLE) return (Cable) link;
    }
    return null;
  }
  PTPLink searchPTPLink(int ID) {
    for (int i=0; i<links.size(); i++) {
      Link link = (Link) links.elementAt(i);
      if (ID == link.getID() && link.type == PTPLINK) return (PTPLink) link;
    }
    return null;
  }
  public String toString() {
    String s="";
    for (int i=0; i<nodes.size(); i++) {
      Node n = (Node) nodes.elementAt(i);
      s += n.toString();
    }
    for (int i=0; i<links.size(); i++) {
      Link l = (Link) links.elementAt(i);
      s += l.toString();
    }
    return s;
  }
  // parsing the input file and reconstruct the network
  public boolean reconstruct(DataInputStream in) {
    String line;
    objID = 0;
    for (int i=1; i<=NoOfObjects; i++) {
      objNo[i] = 0;
    }
    nodes = new Vector(10, 10);
    links = new Vector(10, 10);
    malinks = new Vector(10, 10);
    routers = new Vector(10, 10);
    switches = new Vector(10, 10);
    try {
      while ((line = in.readLine()) != null) {
        StringTokenizer tmp;
        tmp = new StringTokenizer(line);
        if (!tmp.hasMoreTokens()) {
          System.err.println("no more token!\n");
          System.exit(1);
        }
        AttrValue av = new AttrValue(tmp);
        //System.out.println("return from getAttr() name="+av.name+" value="+av.value);
        int type = Integer.parseInt(av.value);
        if (type == CLIENT) {
          Client c = new Client(this, tmp, type);
        }
        if (type == SERVER) {
          Server s = new Server(this, tmp, type);
        }
        if (type == CACHE) {
          CacheServer c = new CacheServer(this, tmp, type);
        }
        if (type == DNS) {
          DNS d = new DNS(this, tmp, type);
        }
        if (type == LBA) {
          LBA l = new LBA(this, tmp, type);
        }
        if (type == ROUTER) {
          Router r = new Router(this, tmp, type);
        }
        if (type == SWITCH) {
          Switch sw = new Switch(this, tmp, type);
        }
        if (type == PTPLINK) {
          PTPLink l = new PTPLink(this, tmp, type);
        }
        if (type == MALINK) {
          MALink l = new MALink(this, tmp, type);
        }
        if (type == CABLE) {
          Cable c = new Cable(this, tmp, type);
        }
      }
      f.mapArea.repaint();
      return true;
    }catch (IOException e) {
        System.err.println("readSectors() exception");
        System.err.println(e);
        return false;
    }
  }
  public void logPrintln(String s) {
    //System.out.println(s);
    logPW.println(s);
  }
  public void println(String s) {
    if (verbose) System.out.println(s);
    try {
      if (debug) debugOS.writeBytes(s+"\n");
    } catch (IOException e) {
        System.err.println("File not open properly\n"+e.toString());
        System.exit(1);
    }
  }
  public void print(String s) {
    if (verbose) System.out.print(s);
    try {
      if (debug) debugOS.writeBytes(s);
    } catch (IOException e) {
        System.err.println("File not open properly\n"+e.toString());
        System.exit(1);
    }
  }
  public void startSimulation() {
    try {
        debugOS = new DataOutputStream(
                  new FileOutputStream("debug.dat"));
        logPW = new PrintWriter( new OutputStreamWriter(
                                 new FileOutputStream("session.dat")));

    } catch (IOException e) {
        System.err.println("File not open properly\n"+e.toString());
        System.exit(1);
    }
    FloydAlgorithm();  // for calcuating routing table

    logPrintln("befoer simulation:\nnetobjID="+objID+" cdl:\n"+cdl.toString());
    // initialize the starting events
    el = new EventList();
    for (int i=0; i<nodes.size(); i++) {
      Node n = (Node) nodes.elementAt(i);
      n.localTime = 0.0;
      if (n.type == CLIENT) {
        er = new EventRecord(0.0, n.ID, -1, n.ID);
        er.addField("msgType", "init");
        //System.out.println("send init to Client "+n.name);
        println("send init to Client "+n.name);
        el.queueEvent(er);
      }
    }
    er = new EventRecord(300.0, -1, -1, -1);
    el.queueEvent(er);
    verbose = false;
    // start event dispatching
    while ((er = el.nextEvent())!= null) {

      if (er.next == -1) {
        //System.out.println("Time up! stop simulation");
        verbose = true;
        println("Time up! stop simulation");
        if (noOfFinishedRequests != 0) {
          //System.out.println("avg end-to-end response time="+
          //   totalEndToEndRespTime/noOfFinishedRequests);
          println("avg end-to-end response time="+
            totalEndToEndRespTime/noOfFinishedRequests);
          println("noOfFinishedRequest="+noOfFinishedRequests);
        } else
          //System.out.println("no successful request delivery.");
          println("no successful request delivery.");

        cdl.sort();
        logPW.println(cdl.toString());
        TableSorterDemo frame1 = new TableSorterDemo(this);
        // frame.pack();

      frame1.validate();

    frame1.setLocation(50,50);
    frame1.setSize(700,700);
        frame1.setVisible(true);
        try {
          debugOS.close();
          logPW.close();
        } catch (IOException e) {
          System.err.println("File not close properly\n"+
                              e.toString());
          System.exit(1);
        }
        return;
      }
      if (er.next == -2) { // animation event
        // retrieve data in the EventRecord for display the animation image
        if (debug) System.err.println("enter animation event");

       try {
        // generate the next event in the next position if step < net.animationMaxSteps
        int step = Integer.parseInt(er.getField("step"));
        String reqID = er.getField("reqID");
        if (step == 0) {
          f.mapArea.addMsg(reqID, er);  // add animation msg to mapArea
        }
        int nextStep = step + 1;
        if (nextStep <= animationMaxSteps) {
          er.addField("step", ""+nextStep);
          if (debug) System.err.println("Animation: reqID="+reqID+", step="+step);
          Double d = Double.valueOf(er.getField("deltaTime"));
          double deltaTime = d.doubleValue();
          er.time = er.time + deltaTime;
          el.queueEvent(er);          
        } else {
          f.mapArea.removeMsg(reqID);
        }
       } catch (NumberFormatException e) {
         System.err.println("MALink: Could not convert string to double " + e.toString());
         logPW.close();
         System.exit(1);
       }
        f.mapArea.redo();
        continue;
      } 
      Node next = (Node) searchNode(er.next);

      if (next.type == CLIENT) {
        Client c = (Client) next;
        c.eventHandle(er);
      }
      if (next.type == SERVER) {
         Server c = (Server) next;
        c.eventHandle(er);
      }
      if (next.type == CACHE) {
        CacheServer c = (CacheServer) next;
        c.eventHandle(er);
      }
      if (next.type == DNS) {
        DNS c = (DNS) next;
        c.eventHandle(er);
      }
      if (next.type == LBA) {
        LBA c = (LBA) next;
        c.eventHandle(er);
      }
      if (next.type == ROUTER) {
        Router c = (Router) next;
        c.eventHandle(er);
      }
      if (next.type == SWITCH) {
        Switch c = (Switch) next;
        c.eventHandle(er);
      }
      if (next.type == MALINK) {
        MALink c = (MALink) next;
        c.eventHandle(er);
      } 
    }
    try {
      debugOS.close();
      logPW.close();
    } catch (IOException e) {
      System.err.println("File not close properly\n"+
                          e.toString());
      System.exit(1);
    }
  }
  public int findDist(int i, int j) {
    Node n1 = (Node) nodes.elementAt(i);
    Node n2 = (Node) nodes.elementAt(j);
    for (int k=0; k< n1.links.size(); k++) {
      Link l = (Link) n1.links.elementAt(k);
      if (l.n1.ID == n1.ID) {
        if (l.n2.ID == n2.ID) return 1;
      } else {
        if (l.n1.ID == n2.ID) return 1;
      }
    }
    return 99999;
  }
  //
  // implement Floyd62 algorihtm, pp. 163 of Telecomm. Network Design Algorithm
  // the pred array contain the routing direction
  // e.g., pred[i,j]= k shows that from node j to node i takes next node k
  //
  // Here we use findDist(i,j) to find the initial cost between node i and node j
  // Note that the index refers the relative position in nodes vector
  // it is not the ID of the node.
  //
  public void FloydAlgorithm() {
    int n = nodes.size();
    pred = new int[n][n];
    //dist = new int[n][n];
    sp_dist = new int[n][n];

    for (int i=0; i <n; i++)
      for (int j=0; j<n; j++) {
        sp_dist[i][j]= findDist(i,j);
        pred[i][j] = i;
        //output.writeBytes("pred["+i+","+j+"] = "+pred[i][j]+"\n");
      }
      //output.writeBytes("After calculation\n");
      print("After calculation\n");

    for (int k=0; k<n; k++)
      for (int i=0; i<n; i++)
        for (int j=0; j<n; j++) {
          if (sp_dist[i][j] > sp_dist[i][k]+sp_dist[k][j]) {
            sp_dist[i][j] = sp_dist[i][k]+sp_dist[k][j];
            pred[i][j] = pred[k][j];
          }
        }

      for (int i=0; i<n; i++)
        for (int j=0; j<n; j++)
          //output.writeBytes("pred["+i+","+j+"] = "+pred[i][j]+"\n");
          print("pred["+i+","+j+"] = "+pred[i][j]+"\n");

  }
  public int getIndexInNodeVector(int id) {
  // can be improved by have an index field at each node
  // that keep track of the index at nodes vector

    for (int i=0; i< nodes.size(); i++) {
      Node n = (Node) nodes.elementAt(i);
      if (n.ID == id) return i;
    }
    return -1;
  }
  public Link getNextLink(int srcID, int dstID) {
    int src = getIndexInNodeVector(srcID);
    int dst = getIndexInNodeVector(dstID);
    int nextNodeIndex = pred[dst][src];
    Node srcNode = searchNode(srcID);
    Node nextNode = (Node) nodes.elementAt(nextNodeIndex);
    for (int i=0; i< srcNode.links.size(); i++) {
      Link l = (Link) srcNode.links.elementAt(i);
      if (l.n1 == nextNode) return l;
      if (l.n2 == nextNode) return l;
    }
    return null;
  }

}