/** 
  * Route Loader Panel
  * @author Robert J Morton <rob@robmorton.20m.com>
  * @version 04 December 2007
  * @copyright Robert J Morton (all rights reserved) */

/* This applet conforms to API 1.1  
   It does the following:

   INITIALISATION SEQUENCE

   1. Loads a list of names of air routes from a file located on the server, 
      and places them into a "routes" Choice list.

   2. Selects the first one in the list and loads the list of waypoints that
      make up a selected route.


   USER-INITIATED ACTIONS

   1. User can select another route from the list. The new route's list of 
      waypoints is then loaded from the server into the waypoints Choice list. 

   2. User can select a waypoint from the waypoint Choice list. 

   3. User can enter a word or phrase and search for it within all route names
      in the list of routes. If found, the first route's name is selected and
      its waypoints loaded. Pressing the Find/Next button again proceeds with
      the search onwards down the list of routes. */

import java.io.*;   // file input/output handling
import java.net.*;  // for downloading data from the remote server

class loader {  // TO LOAD AND DISPLAY ROUTE NAMES AND GEOGRAPHIC FEATURES

  private static loader ld; // reference to current instance of loader class

  private boolean
    loadingNamesFTT = true,   // This is the first pass of the program
    loadingFeatures = false,  // Loading routes, TRUE = loading features
    namesLoaded = false,      // Route names not yet loaded
    featuresLoaded = false;   // Selected route's waypoints not yet loaded

  int
    NR = 0,  // number of available routes
    NF[],    // number of features in each route
    NW[],    // number of these that are waypoints
    rn = 0,  // index number of current route during loading
    fn = 0,  // index number of current feature within current route
    nf = 0;  // total number of geographic features in current route

  private int
    lp = 0,  // 0=idle 1=connecting 2=loading 3=connect error 4=load error
    L = 0,   // length of the remote item being loaded
    l = 0,   // number of bytes of the above successfully downloaded
    m = 0;   // message index

  private byte B[];  // gigantic byte array to hold the downloaded index data

  private String 
    loadFile = "names.txt",  // name of the route names file

    E,   // for Exception during downloading + method where it occurred
    cb;  // URL path to data files

  // for reading in the route and waypoint lists from files
  private BufferedReader R;

  // input stream for downloading index of current HTML file
  private InputStream I;

  // REFERENCES TO.........
  private movmap mm;    // the parent applet class
  private route ROUTE;  // object of current route
  private msgpanel mp;  // current instance of the message panel class
  private routesel rs;  // current instance of route selector class
  private selwp ws;     // current instance of waypoint selector class
  private butpanel bp;  // the button panel object
  private aircraft ac;  // rthe aircraft object
  private airmap am;    // airmap object
  private navpanel np;  // navigation data panel object
  private dandb db;     // rdistance and bearing calculation object
  private route r;      // a route object
  private waypnt w;     // a waypoint object


  loader(String cb, movmap mm, msgpanel mp, routesel rs, selwp ws, 
         aircraft ac, airmap am, navpanel np, selgeoid gs, butpanel bp) {

    ld = this;     // reference to this instance of this class
    this.cb = cb;  // URL (less file name) from where this applet came
    this.mm = mm;  // context reference of calling applet
    this.mp = mp;  // message panel reference
    this.bp = bp;  // reference to the button panel object
    this.rs = rs;  // reference to route selector menu
    this.ws = ws;  // reference to waypoint selector menu
    this.ac = ac;  // reference to the aircraft object
    this.am = am;  // reference to airmap object
    this.np = np;  // reference to navigation data panel object

    db = gs.getDandB();  // get reference to the distance and bearing object

    lp = 1;  // start the route names loading process
  }


  void loadRoute(int sr) {   // LOAD THE FEATURES OF A SELECTED ROUTE
    featuresLoaded = false;  // selected route's waypoints not yet loaded
    loadingFeatures = true;  // state type of file being loaded

    // form string version of the selected route number
    loadFile="route" + pad(sr) + ".txt";

    waypnt.killAll();  // remove all currently installed waypoints
    nf = NF[sr];       // number of geographic features within route
    fn = 0;            // index of a geographic feature within route
    int x = NW[sr];    // number of waypoints in the selected route

    /* Create a new route with the required number of waypoints
    and clear the previous route's features from Choice Menu. */

    r = new route(x,ac,bp);
    ws.clearWaypoints(x);

    lp = 1;  // start the features loading process
  }


  // CONNECT TO THE APPROPRIATE DATA FILE ON THE SERVER
  private void fileConnect() {

    /* Display the 'Connecting to server...' message. The 'true'
    means that this is an informative message [as opposed to an
    error message]. The 'false' means 'not image load'. */

    mp.showMsg("Connecting to server...",true,false);

    try {  // capture any exceptions locally

      /* If loading from a '.jar' file, create a stream to
      load file from the applet's jar file. We need to set
      the standard file length because it is not easy to
      determine the content length of a jarred data file. */

      if(mm.JarredRoutes) {
        I = getClass().getResourceAsStream(loadFile);
        L = 4096;
      }
      /* Otherwise, if loading directly from the remote server,
      create a stream to load file from remote server, use this
      to form the url of the route data file, open a connection
      to the remote file, create an input stream object to access
      the file and get the length of the remote file (in bytes). */

      else {
        URL url = new URL(cb + loadFile);
        URLConnection u = url.openConnection();
        I = u.getInputStream();
        L = u.getContentLength();
      }
      B = new byte[L];  // Create a gigantic buffer for the data
      l = 0;            // zero the number of bytes so far downloaded
      lp = 2;           // advance to the index loading phase
    } 
    /* If any exception at all occurs, note the type of exception
    and where it occurred, display the exception message on the
    browser's status line and reset loader to its idle state. */

    catch(Exception e) {
      E = "fileConnect() " + e; mm.showStatus(E);
      lp = 4;
      if(loadingFeatures) 
        mp.showMsg("Couldn't find waypoints file.", false, false);
      else
        mp.showMsg("Couldn't find routes file.", false, false);
    } 
  }


  // DOWNLOAD THE APPROPRIATE DATA FILE
  private void fileLoad() {
    if(loadingFeatures) 
      mp.showMsg("Loading waypoints...", true, false);
    else 
      mp.showMsg("Loading route names...", true, false);

    int k;  // current byte being read()
    try {   // if read() hasn't hit the current end of input stream

      /* If loading from the applet's '.jar' file, then
      while the entire file has not yet been downloaded,
      add its new byte to the big byte array. Note that,
      in this case, the total content length is unknown. */

      if(mm.JarredRoutes)
        while((k=I.read()) != -1)
          B[l++] = (byte)k;

      /* Otherwise, we are loading directly from the remote server.
      Since the remote content length is known, while more bytes
      are expected add new bytes to the big byte array. */
      else
        while(l<L && (k=I.read()) != -1)
          B[l++] = (byte)k;

      I.close();  // Close the URL Connection's [or local file's]
      lp = 3;     // input stream and go to the post-loading phase.
    }
    catch(Exception e) {  // if an exception occurred during the try
      E = "fileLoad() "   // state where the exception occurred
        + e               // the type of exception that occurred
        + L               // the total length of the content and how much
        + " " + l;        // of it was downloaded when exception occurred.
      mm.showStatus(E);   // display exception msg on browser's status bar
      lp = 5;             // reset loader to its idle state
      if(loadingFeatures) 
        mp.showMsg("Couldn't load waypoints.", false, false);
      else 
        mp.showMsg("Couldn't load route names.", false, false);
    }
  }


  // TRANSFER LOADED DATA FROM BYTE ARRAY
  private void postLoad() {

    try {  // allow WHILE loop to be interrupted by external events

      R = new BufferedReader(
        new InputStreamReader(
          new ByteArrayInputStream(B)
        )
      );
      /* While there are more lines of text to be extracted from the
      big byte array, read the next line and add it to the accumulation
      string 's'. Close the byte array reader when finished. */

      String s;
      while((s = R.readLine()) != null)
        extract(s);
      R.close();
    }
    catch(Exception e) { }  // ignore any errors. it's local.
    B = null;               // garbage the byte array to release memory

    /* If loading a route's list of waypoints, initialize the newly-
    loaded route, reset aircraft to start of the current route, install
    all the waypoints in the Choice menu, signal that this route's way-
    points are loaded, display the initial air map content, display the
    initial navigation data and reset the loader to its idle state. */

    if(loadingFeatures) {
      r.init(); r.reset(); ws.installWaypoints(); featuresLoaded = true;
      am.atualizar(); np.atualizar(); bp.setBlack();
      mp.showMsg("Flight ready to depart.", true, false); lp = 0;

    /* Otherwise, the list of route names is being loaded, install
    all the routes in the Choice menu the following call uses the
    state of this flag and pre-select the default route name. */

    } else {
      rs.installRoutes();
      namesLoaded = true;
      loadRoute(0);
    }
  }


  boolean routeDataLoaded() {        // RUN THE AUXILIARY THREAD
    switch(lp) {                     // THE 2 DOWNLOADING PHASES
      case 1: fileConnect(); break;  // connect to index resource on server
      case 2: fileLoad(); break;     // manage the downloading of its content
      case 3: postLoad();            // post-loading phase
    }
    return (namesLoaded && featuresLoaded);
  }


  /* Interpret an incoming waypoint entry back into humanly readable form
  Format of input line   *+000000+000000Name
                         0123456789012345
  Format of output line  *000:00:00N 000:00:00W Name */

  private String interpret(String s) {
    return 
      format(Integer.parseInt((s.substring(1,8)).trim()),true)
    + format(Integer.parseInt((s.substring(8,15)).trim()),false)
    + s.substring(15,s.length());
  }

  // re-format a latitude or longitude
  private String format(int x, boolean lat) {

    String S;      // North/South/East/West indicator string
    if(x < 0) {    // If the latitude or longitude be negative
      if(lat)      // if it's a latiude
        S = "S";   // then it must be South
      else         // else it's not a latitude so it must be a longitude
        S = "W";   // so it must be West
      x = -x;      // reverse its sign to make its magnitude positive
    }
    else           // else it must be a positive latitude or longitude
    if(lat)        // so if it is a latitude 
      S = "N";     // which must therefore be North
    else           // else it's not a latitude so it must be a longitude
      S = "E";     // which must therefore be East

    /* convert the latitude or longitude to whole degrees
    'd', whole minutes 'm' and whole seconds 's'. */

    int d = x / 3600, s = x % 3600, m = s / 60; s %= 60;

    int l = 3;      // 3-digit degrees for longitude
    if(lat) l = 2;  // 2-digit degrees for latitude

    /* Turn whole degrees, whole minutes and whole seconds into
    strings and pad them out with leading zeros as necessary. */

    String D = "" + d; while(D.length() < l) D = "0" + D;
    String M = "" + m; while(M.length() < 2) M = "0" + M;
    String X = "" + s; while(X.length() < 2) X = "0" + X;

    // return the full latitude or longitude in readable format
    return D + ":" + M + ":" + X + S + " ";
  }


  // This is executed for each line of the route names file or waypoints file. 
  private void extract(String s) {

    if(loadingFeatures) {  // if loading a route's list of waypoints

      /* Create a new waypoint object containing the geographic
      feature's latitude and longitude in radians, its name, and
      references to the aircraft's distance and bearing objects. */

      w = new waypnt(secRad(s,1,8),secRad(s,8,15),s.substring(15),ac,db);

      /* If this geographic feature is an en-route waypoint,
      add it to the current route and add a re-formatted
      version to the current route's waypoints list. */

      if(s.substring(0,1).equals("*")) {
        r.AddWayPnt(w);
        ws.addWaypoint(interpret(s));
      }

      fn++;  // increment the feature number

    /* Otherwise, it is not a waypoint. So, if loading the first line of
    the route names file, store the number of available routes, create an
    array for the numbers of features in each route and one for the numbers
    of waypoints in each route, set up an array in selwp for route names
    and set its index to the first route. Then set the 'loading names first-
    time-through' flag false to avoid doing this setup phase each pass. */

    } else if(loadingNamesFTT) { 
         NR = Integer.parseInt(s.trim());
         NF = new int[NR];
         NW = new int[NR];
         rs.clearRoutes(NR);
         rn = 0;
         loadingNamesFTT = false;

    /* Otherwise, must be loading an ordinary route name, save the total
    number of features in this route, save the number of these that are
    waypoints, add the route name to the routes choice list array. */

    } else { 
      NF[rn] = si(s, 0, 3); NW[rn++] = si(s, 4, 7); 
      rs.addRoute(s.substring(8));
    }
  }

  // convert 3-digit String to integer value
  private int si(String s, int x, int y) {
    return Integer.parseInt((s.substring(x,y)).trim());
  }

  // convert seconds of arc to radians
  private double secRad(String s,int x,int y){
    int z = Integer.parseInt((s.substring(x,y)).trim());
    return (double)z * Math.PI / 648000;
  }

  // return int as a 3-digit string with leading zeros
  private static String pad(int x) {
    if(x > 998) return "999";
    String s = "" + x;
    while(s.length() < 3)
      s = "0" + s;
    return s;
  }

  // return the status of the namesLoaded flag
  boolean getNamesLoaded(){ return namesLoaded; }

  int getlp(){return lp;}
  void setlp(int x){lp = x;}
  boolean DefaultsLoaded(){return (namesLoaded && featuresLoaded);}
}