/* SCCS  %W--- 09/20/99 -- 19:17:52 */

// Copyright: Copyright (c) 1997 University of Southern California Brain Project.
// Copyright: This software may be freely copied provided the toplevel
// Copyright: COPYRIGHT file is included with each such copy.
// Copyright: Email nsl@java.usc.edu.

//
// NslMain.java
//
//////////////////////////////////////////////////////////////////////

/**
* The main routine.
  Instantiate all esstential components in the simulator and
  launch interpreter.
*/
//import tcl.lang.*;

import nslj.src.system.*;
import nslj.src.cmd.*;
import nslj.src.lang.*;
import nslj.src.math.*;
import nslj.src.display.*;
//import nslj.src.nsls.struct.*;

public class NslMain {
  static public boolean TopLoaded =false;
  static NslInterpreter interpreter;
  static NslScheduler scheduler;
  //static NslScheduler trainScheduler;
  static NslSystem system; 

  static String modelname;
  private static boolean noDisplay=false;
  private static boolean smallScreen=false;
  private static boolean stdout=true;
  private static boolean stderr=false;
  private static int debug=0;
  private static String schedulerMethod="pre";

  private static NslExecutive executive;

  /**
   * Main routine for NslMain application.
     It calls <tt>main()</tt> with no args
     to instantiate essential components in the
     simulator and launch the interpreter for user input.
   */

public static void main(String argv[]) {
    int dummy1,dummy2;
        if (argv.length==0 || argv.length == 1 &&
        (argv[0].compareTo("-0")==0 || argv[0].compareTo("-h")==0)) {
        System.err.println(
        "Error in NslMain: correct usage is:  java NslMain <Model>");
        return;
    }
    modelname=argv[0];
    //System.out.println("Debug: NslMain: Loading "+modelname);
    // What do all of these do?  aa 98/8/4
    for(int i=1;i<argv.length;i++) {
        if(argv[i].compareTo("-debuglex")==0) {}
        else if(argv[i].compareTo("-debugparse")==0) {}
        else if(argv[i].compareTo("-lex")==0) {}
        else if(argv[i].compareTo("-l")==0) {
            if(i == argv.length) {
                System.err.println("-l requires an argument");
                return;
            }
            i++;
            try {
                dummy1 = (Integer.valueOf(argv[i])).intValue();
            } catch (Exception e) {
                System.err.println("-l requires an integer argument");
                return;
            }
        } else if(argv[i].compareTo("-p")==0) {
            if(i == argv.length) {
                System.err.println("-p requires an argument");
                return;
            }
            i++;
            try {
                dummy2 = (Integer.valueOf(argv[i])).intValue();
            } catch (Exception e) {
                System.err.println("-p requires an integer argument");
                return;
            }
        } else if(argv[i].compareTo("-stdout")==0) {
            if(i == argv.length) {
                System.err.println("-stdout requires an argument [console|executive]");
                return;
            }
            i++;
            if(argv[i].compareTo("executive")==0) {
            	stdout = true;
            } else {
            	stdout = false;
            }
        } else if(argv[i].compareTo("-stderr")==0) {
            if(i == argv.length) {
                System.err.println("-stderr requires an argument [console|executive]");
                return;
            }
            i++;
            if(argv[i].compareTo("executive")==0) {
            	stderr = true;
            } else {
            	stderr = false;
            }
        } else if(argv[i].compareTo("-noDisplay")==0) {
		noDisplay=true;
        } else if(argv[i].compareTo("-smallScreen")==0) {
		smallScreen=true;
        } else if(argv[i].compareTo("-debug")==0) {
            if(i == argv.length) {
                System.err.println("-debug requires a positive numeric level: 0=none to 1,000,000.");
                return;
            }
            i++;
            try {
                dummy1 = (Integer.valueOf(argv[i])).intValue();
		debug=dummy1;
            } catch (Exception e) {
                System.err.println("-debug requires an integer argument");
                return;
            }
        } else if(argv[i].compareTo("-schedulerMethod")==0) {
            if(i == argv.length) {
                System.err.println("-schedulerMethod requires a string: pre, post, mixed");
                return;
            }
            i++;
            try {
		schedulerMethod=argv[i];
            } catch (Exception e) {
                System.err.println("-schedulerMethod requires a string: pre, post, mixed");
                return;
            }

	}
    } //end for argvs

    main();   // CALL TO MAIN
    //   old
    //    interpreter.execute();
    //    System.exit(0);
}


	/**
 	 Application launcher.
	 Add user command, differential methods, modules into the main
	 system.
 	*/
  
	public static void main() {
		NslCmd c;
		NslCmd d;

		system = new NslSystem();
 		system.setSmallScreen(smallScreen);		//98/9/22 aa
		system.setNoDisplay(noDisplay);			//98/8/4 aa
		system.setDebug(debug);				//98/8/4 aa
		system.nslSetSchedulerMethod(schedulerMethod);	//98/9/11 aa

		interpreter = new NslInterpreter(system);
		system.setInterpreter(interpreter);
 		
                //trainScheduler = new NslTrainMultiClockScheduler(system);
                //system.setTrainScheduler(trainScheduler);
		
		scheduler      = new NslMultiClockScheduler(system);
		system.nslSetScheduler(scheduler);

		//NslModule.nslSetSystem(system);  //99/6/21 aa
		// replaces with NslHierarchy since
	      // the inits were seeing system as null;
		NslHierarchy.nslSetSystem(system);


		addDefaultDiffMethods();
		//NslMath.nslSetSystem(system);

		addDefaultCmd();
		//addDefaultModels();
		loadModel(modelname);
	}


  /**
   * Add all differential / numerical methods to the system.
     Setup the default numerical methods to run.
  */
  static void addDefaultDiffMethods() {
    NslDiff diff = (NslDiff) (new NslDiffEuler(system));
    system.addApproximationMethod(diff);
    system.nslSetApproximationMethod(diff);
  }


  /**
   * Add user commands to the system and interpreter.
   */
  static void addDefaultCmd() {
    NslCmd.nslSetSystem(system);

    system.addCommand(new NslCmdInitSys());

    system.addCommand(new NslCmdInitModule());

    system.addCommand(new NslCmdInitTrainEpoch());
    system.addCommand(new NslCmdInitTrain());
    system.addCommand(new NslCmdDoTrainEpochTimes());
    system.addCommand(new NslCmdSimTrain());
    system.addCommand(new NslCmdTrain());
    system.addCommand(new NslCmdEndTrain());
    system.addCommand(new NslCmdEndTrainEpoch());

    system.addCommand(new NslCmdInitRunEpoch());
    system.addCommand(new NslCmdInitRun());
    system.addCommand(new NslCmdDoRunEpochTimes());
    system.addCommand(new NslCmdSimRun());
    system.addCommand(new NslCmdRun());
    system.addCommand(new NslCmdEndRun());
    system.addCommand(new NslCmdEndRunEpoch());

    system.addCommand(new NslCmdTrainAndRunAll());

    system.addCommand(new NslCmdStepCycle());
    system.addCommand(new NslCmdStepEpoch());
    system.addCommand(new NslCmdStepModule());

    system.addCommand(new NslCmdCont());
    system.addCommand(new NslCmdContCycle());
    system.addCommand(new NslCmdContEpoch());
    system.addCommand(new NslCmdContModule());

    system.addCommand(new NslCmdBreak());
    system.addCommand(new NslCmdBreakCycles());
    system.addCommand(new NslCmdBreakEpochs());
    system.addCommand(new NslCmdBreakModules());

    system.addCommand(new NslCmdEndModule());

    system.addCommand(new NslCmdEndSys());

    system.addCommand(new NslCmdExit());
  }

	/**
	 * Add models to the system. All the corresponding child modules
	   are instantiated and registered in the schduler.
	*/
	static void addDefaultModels()  {}
  
	static void loadModel(String s)  {
        	NslModule module;
		NslDisplaySystem ds;
        	Class cl;
        	
		try {
			cl     = Class.forName(s);
			// the following line not only instantiates the
			// model, it also instantiates the children and grandchildren
			module = (NslModule)cl.newInstance();

			
			//system.setCurrentModel(module); //moved into addModel
			//System.out.println("Debug: NslMain: current module set!!");
			//System.out.println("Debug: NslMain: module added!!");
			
			NslFrame.nslSetSystem(system);
			
			if (noDisplay) {
				//System.out.println("Debug: NslMain: noDisplay mode processing!!");
				//98/8/4 aa: same as start or run but input from the console
				system.addModel(module,noDisplay); 
				interpreter.execute();
				
				// The next line is never executed
				System.exit(0);
			} else {	
	
				//System.out.println("Debug: NslMain: interactive mode: display frame set!!");
				executive = new NslExecutive(system);
    				executive.show();
    				
    				NslOut out = new NslOut(System.out);
    				
    				if (stderr) {    				
    				    System.setErr(out);
    				}

    				if (stdout) {    				
    				    System.setOut(out);
    				}

				system.addModel(module,noDisplay); 
    		
				if (system.getNumberOfDisplays()== 0) {
				    ds = new NslDisplaySystem(module, system); 
				    system.addDisplaySystem(ds);
				    
				    module.nslInitWindow(ds.frame);
				}
	        
				// ashell=new Ashell(module,ds.frame,205,200);
				// 98/9/22 aa: added for doing demos on 800x600 monitors=smallScreen
				// if (smallScreen) {
				// 	ashell.setLocation(0,400);
				// } else {
				// 	ashell.setLocation(0,550);
				// }
				// Thread t=new Thread(null,ashell,"ashell");
				// t.setPriority(Thread.MAX_PRIORITY);
				// t.start();
			}
		} catch (Exception e) {
			System.err.println("Error: NslMain: ["+e.toString()+"]  when loading/constructing model "+ modelname+".class");
			e.printStackTrace();
 		}
	}
}