/** GPApplet.java
  * J Scott Cameron
  *
  * This is an applet which uses Genetic Programming
  * for Symbolic Regression
  */
import javax.swing.*;
import java.awt.*;
import java.applet.*;
import java.util.*;
import java.awt.event.*;
import java.io.*;
import Operators;
import GPPopulation;
import GPNode;
import GPPair;
import GPNodeContainer;
import GaGraph;
import GPCompGraph;

public class GPApplet extends JApplet 
implements ActionListener,ItemListener{
    
    private Operators operators; /* operators for symbolic regression */
    private Random random;
    private GPPopulation population; /* population of Genetic Programs*/
    private Vector gpHistory; /* best GP's, for graph */
 
    /* swing components*/
    private JLabel  bestGPScore;
    private JLabel  bestGPGen;
    private JLabel  generationsAdvanced;
    
    private JTextArea possibleFunctions;
    private JTextArea defineFunction;
    private JButton setFunction;
    private JTextField xMin;
    private JTextField xMax;
    private JLabel lMessage;
  
    private JButton resetGP;
    private JButton nextGen;
    private JButton manyGens;
    private JTextField numGens;
    private JTextField popSize;
    private JCheckBox mutation;
    private JCheckBox crossover;
    private JTextField mutationRate;

    private int generation;
    private GpGraph graph;

    private GPNodeContainer bestGP;
    
    private JButton graphComparison;
    private GPCompGraph compGraph;
    private JTextField compXMin;
    private JTextField compXMax;
    private JTextField compYMin;
    private JTextField compYMax;
    
    
    /* booleans to keep track of the state of their appropriate check
     * boxes */
    private boolean crossoverBool = true;
    private boolean mutationBool = true;
    
    
    // This is a hack to avoid an ugly error message in 1.1.
    public GPApplet()
    {
        getRootPane().putClientProperty("defeatSystemEventQueueCheck",
        Boolean.TRUE);
    }
    
    /* initializes applet */
    public void init() {
        
        /* set Look and Feel to standard Swing look and feel */
        try {
            UIManager.setLookAndFeel(
            UIManager.getCrossPlatformLookAndFeelClassName());
        } catch (Exception e) { }
        
        
        random = new Random();
        
        operators = new Operators();
        /* create an initail population */
        population = new GPPopulation(operators,10,true,true,.01);
        
        
        
        /* initialize swing components */
        JTabbedPane tp = new JTabbedPane();
        tp.setBorder(BorderFactory.createMatteBorder(1,1,2,2,Color.black));
        getContentPane().add(tp, BorderLayout.CENTER);
        
        tp.addTab("Equation Definition",equationPanel());
        tp.addTab("Use Genetic Programming",gpPanel());
        tp.addTab("Comparison Graph",compPanel());
        
        /* set the initial function */
        setFunctionPressed();
        resetGPPressed();
        
    }
    
    
    /* this returns a string of the available functions
     * to be displayed so the user can see their options */
    public String getPossibleFunctionsString()
    {
        StringWriter sw = new StringWriter();
        Vector temp;
        int i;
        temp = operators.getBinaryFunctions();
        sw.write("Binary Functions:\n");
        for(i=0;i<temp.size();i++)
        {
            sw.write("\t");
            sw.write(((GPPair)temp.get(i)).sign);
            sw.write("(Value,Value)\n");
        }
        
        temp = operators.getUnaryFunctions();
        sw.write("Unary Functions:\n");
        for(i=0;i<temp.size();i++)
        {
            sw.write("\t");
            sw.write(((GPPair)temp.get(i)).sign);
            sw.write("(Value)\n");
        }
        
        temp = operators.getVariables();
        sw.write("Variables:\n");
        for(i=0;i<temp.size();i++)
        {
            sw.write("\t");
            sw.write(((GPPair)temp.get(i)).sign);
            sw.write("\n");
        }
        return sw.toString();
        
    }
    
    /* redirect button actions to the appropriate methods */
    public void actionPerformed(ActionEvent evt)
    {
        JButton theItem = (JButton) evt.getSource();
        if (theItem == setFunction) setFunctionPressed();
        else if (theItem == resetGP) resetGPPressed();
        else if (theItem == nextGen) nextGenPressed();
        else if (theItem == manyGens) manyGensPressed();
        else if (theItem == graphComparison) graphPressed();
    }
    
    
    /* change the correct booleans when check boxes are pressed */
    public void itemStateChanged(ItemEvent p1) {
        JCheckBox theItem = (JCheckBox) p1.getItemSelectable();
        
        if(theItem == mutation)
        {
            if(p1.getStateChange() == ItemEvent.DESELECTED)
            {mutationBool = false;
            }
            else
            {mutationBool = true;
            }
            
        }
        else if(theItem ==crossover)
        {
            if(p1.getStateChange() ==ItemEvent.DESELECTED)
            {crossoverBool = false;
            }
            else
            {crossoverBool = true;
            }
        }
    }
    
    /* update the Comparison Graph */
    public void graphPressed()
    {
        compGraph.updateGraph(operators.getFunction(),bestGP.getNode(),
        Double.parseDouble(compXMin.getText()),
        Double.parseDouble(compXMax.getText()),
        Double.parseDouble(compYMin.getText()),
        Double.parseDouble(compYMax.getText()));
    }
    
    /* set the function to be tested */
    public void setFunctionPressed()
    {
        try{
            operators.setFunction(population.makeNodeFromString(
             defineFunction.getText()));
            lMessage.setText("Function loaded successfully");
        }
        catch(IllegalArgumentException e)
        {
            lMessage.setText(e.toString());
        }
        
    }
    
    /* resets the Genetic Program Population */
    public void resetGPPressed()
    {
        /* set the domain to be tested*/
        operators.setDomain(Double.parseDouble(xMin.getText()),
                            Double.parseDouble(xMax.getText()));
        
        /* generate a new population */
        population = new GPPopulation(operators,
                               (new Integer(popSize.getText())).intValue(),
                                crossoverBool,mutationBool,
                          (new Double(mutationRate.getText())).doubleValue());
        
        /* evaluate the population */
        population.evaluatePopulation();
        
        /* reset history vector */
        gpHistory = new Vector();
        
        /* record the best GP */
        bestGP = population.best();
        /* add it to the history */
        gpHistory.add(new GPNodeContainer(bestGP));
        
        generation = 0;
        
        /* update display */
        StringWriter sw = new StringWriter();
        sw.write("Best GP Genotype Found: ");
        sw.write(bestGP.getNode().toString());
        bestGPGen.setText(sw.toString());
        sw= new StringWriter();
        sw.write("Best GP Score: ");
        sw.write((new Double(bestGP.getRating())).toString());
        bestGPScore.setText(sw.toString());
        sw= new StringWriter();
        sw.write("Generations Advanced: ");
        sw.write((new Integer(generation)).toString());
        generationsAdvanced.setText(sw.toString());
  
        /* update the graph */
        graph.updateGraph(gpHistory);
        
        
    }
    
    public void nextGenPressed()
    {
        
        generation++;
        
        /* regenrate/evaluate the population*/
        population.regeneratePopulation();
        population.evaluatePopulation();
        
        /* add the best to the graph */
        gpHistory.add(new GPNodeContainer(population.best()));     
        
        bestGP = population.best();
        
        
        /* update display */
        StringWriter sw = new StringWriter();
        sw.write("Best GP Genotype Found: ");
        sw.write(bestGP.getNode().toString());
        bestGPGen.setText(sw.toString());
        sw= new StringWriter();
        sw.write("Best GP Score: ");
        sw.write((new Double(bestGP.getRating())).toString());
        bestGPScore.setText(sw.toString());
        sw= new StringWriter();
        sw.write("Generations Advanced: ");
        sw.write((new Integer(generation)).toString());
        generationsAdvanced.setText(sw.toString());
        graph.updateGraph(gpHistory);
    }
    
    public void manyGensPressed()
    {
        
        
        
        int gens = (new Integer(numGens.getText())).intValue();
        for(int i=0;i<gens;i++)
        {
            generation++;
         /* regenrate/evaluate the population*/
            population.regeneratePopulation();
            population.evaluatePopulation();
            gpHistory.add(new GPNodeContainer(population.best()));
            
        }
        
        
        bestGP = population.best();
        /* update display */
        StringWriter sw = new StringWriter();
        sw.write("Best GP Genotype Found: ");
        sw.write(bestGP.getNode().toString());
        bestGPGen.setText(sw.toString());
        sw= new StringWriter();
        sw.write("Best GP Score: ");
        sw.write((new Double(bestGP.getRating())).toString());
        bestGPScore.setText(sw.toString());
        sw= new StringWriter();
        sw.write("Generations Advanced: ");
        sw.write((new Integer(generation)).toString());
        generationsAdvanced.setText(sw.toString());
        graph.updateGraph(gpHistory);
    }
    
    /* initialize first panel */
    JPanel equationPanel()
    {
        JPanel jp = new JPanel();
        jp.setLayout(null);
        possibleFunctions = new JTextArea(getPossibleFunctionsString());
        possibleFunctions.setEditable(false);
        JScrollPane scrollPane = new JScrollPane(possibleFunctions);
        scrollPane.setBounds(5,30,585,175);
        JLabel lPossibleFunctions = new JLabel("Possible Functions: ");
        lPossibleFunctions.setBounds(5,5,195,20);
        
        JLabel lDefineFunction = new JLabel("DefineFunction: ");
        lDefineFunction.setBounds(5,210,95,20);
        defineFunction =
        new JTextArea("+(-(*(x,*(x,*(x,x))),*(3,*(x,*(x,x)))),x)");
        JScrollPane scrollPane2 = new JScrollPane(defineFunction);
        scrollPane2.setBounds(5,235,585,40);
        
        setFunction = new JButton("Set Function");
        setFunction.addActionListener(this);
        setFunction.setBounds(5,285,145,20);
        
        JLabel lSetRange =
        new JLabel("Set Domain for Genetic Programs to test");
        lSetRange.setBounds(155,285,300,20);
        
        xMin = new JTextField("-10");
        xMax = new JTextField("10");
        JLabel lxMin = new JLabel("xMin:");
        JLabel lxMax = new JLabel("xMax:");
        
        lMessage = new JLabel("");
        lMessage.setBounds(5,335,585,20);
        
        lxMin.setBounds(155,310,50,20);
        xMin.setBounds(205,310,50,20);
        lxMax.setBounds(255,310,50,20);
        xMax.setBounds(305,310,50,20);
        
        jp.add(scrollPane);
        jp.add(lPossibleFunctions);
        jp.add(lDefineFunction);
        jp.add(scrollPane2);
        jp.add(setFunction);
        jp.add(lSetRange);
        jp.add(xMin);
        jp.add(lxMin);
        jp.add(xMax);
        jp.add(lxMax);
        jp.add(lMessage);
        
        return jp;
    }
    
    
    /* initialize second panel */
    JPanel gpPanel()
    {
        JPanel jp = new JPanel();
        jp.setLayout(null);
        
        
        
        resetGP = new JButton("Reset Genetic Programs");
        resetGP.addActionListener(this);
        resetGP.setBounds(5,5,180,25);
        nextGen = new JButton("Advance Population One Generation");
        nextGen.addActionListener(this);
        nextGen.setBounds(5,35,210,25);
        manyGens = new JButton("Advance Population Multiple Generations");
        manyGens.addActionListener(this);
        manyGens.setBounds(5,65,240,25);
        
        mutation = new JCheckBox("Mutation",true);
        crossover = new JCheckBox("Crossover",true);
        mutationRate = new JTextField(".1",5);
        JLabel lMRate = new JLabel("Mutation Rate:");
        mutation.setBounds(290,5,95,20);
        mutation.addItemListener(this);
        crossover.setBounds(190,5,95,20);
        crossover.addItemListener(this);
        lMRate.setBounds(390,5,95,20);
        mutationRate.setBounds(490,5,30,20);
        
        numGens = new JTextField("5",3);
        JLabel lNGen = new JLabel ("Number of Generations to Advance: ");
        lNGen.setBounds(250,65,200,20);
        numGens.setBounds(455,65,30,20);
        
        popSize = new JTextField("100",4);
        JLabel lPSize = new JLabel("Population Size: ");
        lPSize.setBounds(250,35,100,20);
        popSize.setBounds(355,35,30,20);
        
        bestGPGen = new JLabel("Best GP Genotype Found: Not yet Computed");
        bestGPGen.setBounds(5,120,585,20);
        
        bestGPScore = new JLabel("Best GP Score: Not yet Computed");
        bestGPScore.setBounds(5,95,200,20);
        
        generationsAdvanced = 
        new JLabel("Generations Advanced: Not yet Computed");
        generationsAdvanced.setBounds(210,95,200,20);
        gpHistory = new Vector();
        
        
        graph = new GpGraph(gpHistory);
        graph.setBounds(5,150,580,200);
        
        
        jp.add(resetGP);
        jp.add(nextGen);
        jp.add( manyGens);
        jp.add(mutation);
        jp.add(crossover);
        jp.add(lMRate);
        jp.add(mutationRate);
        jp.add(lNGen);
        jp.add(numGens);
        jp.add(lPSize);
        jp.add(popSize);
        jp.add(bestGPGen);
        jp.add(bestGPScore);
        jp.add(generationsAdvanced);
        jp.add(graph);
        
        return jp;
    }
    
    /* initialize third panel */
    JPanel compPanel()
    {
        JPanel jp = new JPanel();
        jp.setLayout(null);
        
        JLabel lxMin = new JLabel("xMin:");
        lxMin.setBounds(5,5,50,20);
        compXMin = new JTextField("-10");
        compXMin.setBounds(55,5,50,20);
        
        JLabel lxMax = new JLabel("xMax:");
        lxMax.setBounds(5,30,50,20);
        compXMax = new JTextField("10");
        compXMax.setBounds(55,30,50,20);
        
        JLabel lyMin = new JLabel("yMin:");
        lyMin.setBounds(5,55,50,20);
        compYMin = new JTextField("-10");
        compYMin.setBounds(55,55,50,20);
        
        JLabel lyMax = new JLabel("yMax:");
        lyMax.setBounds(5,80,50,20);
        compYMax = new JTextField("10");
        compYMax.setBounds(55,80,50,20);
        
        graphComparison = new JButton("Graph");
        graphComparison.addActionListener(this);
        graphComparison.setBounds(5,105,100,20);
        
        compGraph = new GPCompGraph(operators,
                                    new GPTerminalNode(0),
                                    new GPTerminalNode(0),
                                    -10,10,-10,10);
        compGraph.setBounds(150,5,360,360);
        
        jp.add(lxMin);
        jp.add(compXMin);
        jp.add(lxMax);
        jp.add(compXMax);
        jp.add(lyMin);
        jp.add(compYMin);
        jp.add(lyMax);
        jp.add(compYMax);
        jp.add(graphComparison);
        jp.add(compGraph);
        
        return jp;
    }
   
}