package main;

import java.io.*;
import java.awt.*;
import affectors.Affector;
//import affectors.EnhancerRegion;
//import affectors.EnhancerRegion2;
//import affectors.MultiEnhancer;
//import affectors.Sum;
//import affectors.Product;
import parameters.Parameter;
import parameters.ParameterSet;
import initialconditions.InitialConditionSet;

public class NetInput extends Object {
	int					width, height, numsides;
	Network				net;
	InitialConditionSet	initializers;
	ParameterSet		parameters = new ParameterSet();
	
	/* The following three arrays are used to guess values for parameters that don't
		exist in the input file. The user is warned that the parameter doesn't exist,
		and then if the prefix for the parameter name equals one of the paramTypes below,
		Ingeneue makes a parameter with the values in the other two arrays as defaults. */
	private static final String [] paramTypes = {"K", "nu", "H", "r", "alpha", "beta", "Endo", "Exo", "max", "Mxfer", "LMxfer", "in"};
	private static final float [] paramValues = {0.1f, 0.001f, 1.0f,    2, 1, 10,     10, 1, 1000,
													0.0001f, 0.00001f, 0.001f,    1, 1, 10,   1, 1, 10,   
													0.001f, 0.001f, 1,    0.1f, 0.01f, 10,    1000, 1000, 1000000,
													0.001f, 0.001f, 1,    0.1f, 0.001f, 1,  0.01f, 0.001f, 1.0f};
	private static final String []	paramVarModes = {"Logarithmic", "Linear", "Logarithmic", "Logarithmic", "Logarithmic", "Logarithmic",
													"Logarithmic", "Logarithmic", "Logarithmic", "Logarithmic", "Logarithmic", "Logarithmic"};	
	
	NetInput(BetterTokenizer tokenizer) throws ModelLoadingException {
		net = new Network("Network");
		initializers = new InitialConditionSet();
		initializers.setNetwork(net);
		String info = "";
		try {
			info = GeneralInput.findNextIDToken(tokenizer);
			while(!info.equals("endNetwork")) {
				if(info.equals("width")) {GeneralInput.nextToken(tokenizer); width = (int)tokenizer.nval; }
				else if(info.equals("height")) {GeneralInput.nextToken(tokenizer); height = (int)tokenizer.nval; }
				else if(info.equals("numsides")) {GeneralInput.nextToken(tokenizer); Globals.cellNumSides = numsides = (int)tokenizer.nval; }
				else if(info.equals("Network")) {GeneralInput.nextToken(tokenizer); net.setName(tokenizer.sval); }
				else if(info.equals("Genes") || info.equals("Nodes")) readGenes(tokenizer, net);
				else if(info.equals("Calculators")) readCalculators(tokenizer, net);
				else if(info.equals("Interactions")) readInteractions(tokenizer, net);
//				else if(info.equals("DefaultParameterValues")) readDefaultParameterValues(tokenizer, net);
				else if(info.equals("ParameterValues")) readParameterValues(tokenizer, net);
				else if(info.equals("InitLevels")) initializers.loadParameters(tokenizer, net);
				else if(info.equals("RandomPicks")) readRandomPicks(tokenizer, net);
				info = GeneralInput.findNextIDToken(tokenizer);
			}
		} catch (Exception e) {
			throw new ModelLoadingException("Error while loading " + info +" in model file : " + e.toString(), tokenizer.lineno());
		}
	}
	
	public void readGenes(BetterTokenizer tokenizer, Network net) throws Exception {		
		String gene_name = GeneralInput.findNextIDToken(tokenizer);		
		while(!gene_name.equals("endGenes") && !gene_name.equals("endNodes")) {
			NodeTemplate node = net.addNode(gene_name);
			node.readSetup(tokenizer);
			
			gene_name = GeneralInput.findNextIDToken(tokenizer);
		}
		
	}

	public void readCalculators(BetterTokenizer tokenizer, Network net) throws Exception	{
		String name = GeneralInput.findNextIDToken(tokenizer);		
		while(!name.equals("endCalculators")) {
			NodeTemplate cn = net.addCalculator(name);
			cn.readSetup(tokenizer);
			name = GeneralInput.findNextIDToken(tokenizer);
		}
	}

	public void readInteractions(BetterTokenizer tokenizer, Network net) throws Exception {
		int		side;
		String gene_name = GeneralInput.findNextIDToken(tokenizer);
		while(!gene_name.equals("endInteractions")) {  // read in nodes
			NodeTemplate node = net.getNode(gene_name);
				readInteractionSet(tokenizer, "end" + gene_name, node);
			gene_name = GeneralInput.findNextIDToken(tokenizer);
		}
	}
	

	private void readInteractionSet(BetterTokenizer tokenizer, String end_text, NodeTemplate node) throws Exception {
		String affector_name = GeneralInput.findNextIDToken(tokenizer);
			while(!affector_name.equals(end_text))  {  // read in affectors for this node
				try {
					AffectorTemplate template = new AffectorTemplate(node.getName());
					template.readSetup(tokenizer, affector_name);
					node.addAffector(template);
				} catch(Exception e) {
					// Exception here probably means it didn't recognize the gene or affector name
					System.out.print("Problem loading affector " + affector_name + "  ");
					throw new Exception(e.toString());
				}
				affector_name = GeneralInput.findNextIDToken(tokenizer);
			}
	}

	
	public void readParameterValues(BetterTokenizer tokenizer, Network net) throws Exception {
		int		i;
		
		parameters.setArrangeByModel(true);
		parameters.loadParameterValues(tokenizer, true);
		
		for(i = 0; i < parameters.numParams && i < Affector.firstFreeParam; i++) {
			// If didn't find the parameter, give user a warning message and then make one up
			if(parameters.getParameter(i) == null) {
				String pname = Affector.getParamName(i);
				System.out.println("The parameter " + pname + " was not found in the parameter list");
			
				// Give it some default values
				Parameter par = new Parameter(pname);
				
				// Guess at what the parameter should be
				int j = 0;
				while(j < paramTypes.length && (paramTypes[j].length() > pname.length() 
								|| !paramTypes[j].equals(pname.substring(0, paramTypes[j].length()))))
					j++;
				if(j == paramTypes.length)
				{
					par.setValue(1);
					par.setBounds(1, 10);
					par.setVariationMode("Linear");
				}
				else
				{
					par.setValue(paramValues[j*3+0]);
					par.setBounds(paramValues[j*3+1], paramValues[j*3+2]);
					par.setVariationMode(paramVarModes[j]);
				}
				parameters.setParameter(par, i);
			}
			
			Affector.setParamValue(i, parameters.getValue(i));
			Affector.setParamRange(parameters.getName(i), parameters.getLowerBound(i), 
							parameters.getUpperBound(i), parameters.getVariationMode(i));
		}

		for(; i < Affector.firstFreeParam; i++) {
				System.out.println("Parameter " + Affector.getParamName(i) + " was not found in the parameter list");
		}

		for(i = Affector.firstFreeParam; i < parameters.numParams; i++) {
			if(parameters.getParameter(i) != null)
				System.out.println("Parameter " + parameters.getName(i) + " was not found in the model");
		}
	}


	public void readDefaultParameterValues(BetterTokenizer tokenizer, Network net) throws Exception {
//ELI 2/24/99	It would be good to clear this function out and make a call to Parameter.loadParameters() instead
		
		String param_name = GeneralInput.findNextIDToken(tokenizer);
		while(!param_name.equals("endDefaultParameterValues"))  {   // read in parameter values and ranges
			if(GeneralInput.nextToken(tokenizer) != BetterTokenizer.TT_NUMBER)
				throw new Exception ("Default parameter " + param_name + "was not given a value");
			float num = (float)tokenizer.nval;
			if(GeneralInput.nextToken(tokenizer) != BetterTokenizer.TT_NUMBER)
				throw new Exception ("Default parameter " + param_name + "was not given a lower bound");
			float lower = (float)tokenizer.nval;
			if(GeneralInput.nextToken(tokenizer) != BetterTokenizer.TT_NUMBER)
				throw new Exception ("Default parameter " + param_name + "was not given a upper bound");
			float upper = (float)tokenizer.nval;
			if(GeneralInput.nextToken(tokenizer) != BetterTokenizer.TT_WORD)
				throw new Exception ("Default parameter " + param_name + "was not given a range type");
			String mode = tokenizer.sval;
			Affector.addDefaultParam(param_name, num, lower, upper, mode);

			param_name = GeneralInput.findNextIDToken(tokenizer);
		}
	}



	public void readRandomPicks(BetterTokenizer tokenizer, Network net) throws Exception {
		// Do something
	}

	private Affector getAffector(String name, int side, int num_params, String [] params) throws Exception {
		Class c = Class.forName("affectors." + name);
		Affector aff = (Affector)c.newInstance();
		aff.init(side, num_params, params);
		return aff;
	}
	
}