/* 
	PrioExprApplet.java

	Author:			atze
	Description:	JPC Demo
*/

package nl.uu.cs.jpc;

import nl.uu.cs.laf.* ;

import java.awt.*;
import java.awt.event.*;
import java.applet.*;

public class PrioExprApplet extends Applet 
{
    private Eval pPrios ;
    private Eval pExpr ;
    private Eval pPrios_res ;
    private Eval pExpr_res ;
    
    private long timingStart ;
    private long timingEnd ;
    
    private void setPriosRes( String s )
    {
        pPrios_res = UUParsing.parse.apply3( pPrios, StdFuncs.isEmpty, Str.valueOf( s ) ) ;
    }
    
    private void setExprRes( String s )
    {
        pExpr_res =
            UUParsing.parse.apply3
                ( pExpr.apply1( StdFuncs.tupFirst.apply1( pPrios_res ) )
                , StdFuncs.isEmpty
                , Str.valueOf( s )
                ) ;
    }
    
    private void resetTiming()
    {
        Eval.resetNrEvaluations() ;
        timingStart = System.currentTimeMillis() ;
    }
    
    private void setTiming()
    {
        timingEnd = System.currentTimeMillis() ;
        textFieldTiming.setText( "" + (timingEnd - timingStart) + " ms., " + Eval.getNrEvaluations() + " evals, " + ((float)(timingEnd-timingStart))/Eval.getNrEvaluations() + " ms. per eval" ) ;
    }
    
    private void reEvalPrios()
    {
        setPriosRes( textAreaPriorities.getText() ) ;
        textAreaPrioErrors.setText( Eval.toString( StdFuncs.tupThird.apply1( pPrios_res ) ) ) ;
        reEvalExpr() ;
    }
    
    private void reEvalExpr()
    {
        setExprRes( textAreaExpression.getText() ) ;
        textAreaExprErrors.setText( Eval.toString( StdFuncs.tupThird.apply1( pExpr_res ) ) ) ;
        textFieldExprResult.setText( Eval.toString( StdFuncs.tupFirst.apply1( pExpr_res ) ) ) ;
    }
    
// IMPORTANT: Source code between BEGIN/END comment pair will be regenerated
// every time the form is saved. All manual changes will be overwritten.
// BEGIN GENERATED CODE
	// member declarations
	java.awt.Label labelPriorities = new java.awt.Label();
	java.awt.TextArea textAreaPriorities = new java.awt.TextArea();
	java.awt.TextArea textAreaPrioErrors = new java.awt.TextArea();
	java.awt.Label labelErrors = new java.awt.Label();
	java.awt.Label labelExpression = new java.awt.Label();
	java.awt.TextArea textAreaExpression = new java.awt.TextArea();
	java.awt.TextArea textAreaExprErrors = new java.awt.TextArea();
	java.awt.Label labelTiming = new java.awt.Label();
	java.awt.TextField textFieldTiming = new java.awt.TextField();
	java.awt.Label labelExprResult = new java.awt.Label();
	java.awt.TextField textFieldExprResult = new java.awt.TextField();
// END GENERATED CODE

	boolean isStandalone = false;

    /**
        <pre>
            module Expr where
            import UU_Parsing

            instance Symbol Char

            pDigit = (\d -> ord d - ord '0') <$> pAnyOf ['0'..'9']

            pNat = foldl (\a b -> a*10 + b) 0 <$> pSome pDigit

            f_of_op :: Char -> Int -> Int -> Int
            f_of_op op = case op
                           of '+' -> (\a b -> a+b)
                              '*' -> (\a b -> a*b)
                              '/' -> (\a b -> a `div` b)
                              '-' -> (\a b -> a-b)

            pOp name = f_of_op name <$ pSym name

            pOps names = foldr (<|>) pFail (map pOp names)

            pParens = pPacked (pSym '(') (pSym ')')

            pRoot prios = let pExpr = prios (pNat <|> pParens pExpr) in pExpr

            pAnyOps = pOps <$> pSome (pAnyOf "*+/-^")

            pPrios = pParens $
                     pFoldr ((.), id) (   (   pChainl <$ pSym 'L'
                                          <|> pChainr <$ pSym 'R'
                                          )
                                      <*> pAnyOps
                                      )

            tt p1 p2 inp =
                        do let (res1, restinp, errors1) = parse p1            (const True) inp
                           putStr (show errors1)               
                           let (res2     , _      , errors2) = parse (p2 res1) null        restinp 
                           putStr (show errors2)
                           putStr (show res2)
        </pre>
     */
	public PrioExprApplet() 
	{
        // pDigit = (\d -> ord d - ord '0') <$> pAnyOf ['0'..'9']
        final Eval pDigit =
            UUParsing.pApp.apply2
                ( StdFuncs.charToDigit
                , UUParsing.pAnyOf.apply1( Str.valueOf( "0123456789" ) )
                ) ;
                
        // pVar = (\c -> [c]) <$> pAnyOf ['a'..'z']
        /*
        final Eval pVar =
            UUParsing.pApp.apply2
                ( StdFuncs.listOne
                , UUParsing.pAnyOf.apply1( Str.valueOf( "abcdefghijklmnopqrstuvwxyz" ) )
                ) ;
        */
        
        // pNat = foldl (\a b -> a*10 + b) 0 <$> pSome pDigit
        final Eval pNat = 
            UUParsing.pApp.apply2
                ( StdFuncs.foldl.apply2
                    ( new Function2()
                        {
                            public Object eval2( Object a, Object b )
                            {
                                return Int.valueOf( evalToI(a) * 10 + evalToI(b) ) ;
                            }
                        }
                    , StdVals.zero
                    )
                , UUParsing.pSome.apply1( pDigit )
                ) ;

        // f_of_op :: Char -> Int -> Int -> Int
        // f_of_op op = case op
        //                of '+' -> (\a b -> a+b)
        //                   '*' -> (\a b -> a*b)
        //                   '/' -> (\a b -> a `div` b)
        //                   '-' -> (\a b -> a-b)
        final Eval f_of_op =
            new Function1()
            {
                public Object eval1( Object op )
                {
                    switch ( evalToC(op) )
                    {
                        case '+' : return StdFuncs.intAdd ;
                        case '*' : return StdFuncs.intMul ;
                        case '/' : return StdFuncs.intDiv ;
                        case '-' : return StdFuncs.intSub ;
                    }
                    return StdFuncs.error("missing case") ;
                }
            } ;
            
        // pOp name = (\ left right -> left++right++[name]) <$ pSym name
        /*
        Eval pOp =
            new Function1()
            {
                public Object eval1( final Object name )
                {
                    return
                        UUParsing.pAppL.apply2
                            ( new Function2()
                                {
                                    public Object eval2( Object left, Object right )
                                    {
                                        return
                                            StdFuncs.concat2.apply2
                                                ( StdFuncs.concat2.apply2
                                                    ( left
                                                    , right
                                                    )
                                                , StdFuncs.listOne.apply1( name )
                                                ) ;
                                    }
                                }
                            , UUParsing.pSym.apply1( name )
                            ) ;
                }
            } ;
        */
           
        // pOp name = f_of_op name <$ pSym name
        final Eval pOp =
            new Function1()
            {
                public Object eval1( final Object name )
                {
                    return
                        UUParsing.pAppL.apply2
                            ( f_of_op.apply1( name )
                            , UUParsing.pSym.apply1( name )
                            ) ;
                }
            } ;
        
        // pOps names = foldr (<|>) pFail (map pOp names)
        Eval pOps =
            new Function1()
            {
                public Object eval1( Object names )
                {
                    return
                        StdFuncs.foldr.apply3
                            ( UUParsing.pChoice
                            , UUParsing.pFail
                            , StdFuncs.map.apply2
                                ( pOp
                                , names
                                )
                            ) ;
                }
            } ;

        // pParens = pPacked (pSym '(') (pSym ')')
        final Eval pParens =
            UUParsing.pPacked.apply2
                ( UUParsing.pSym.apply1( new Character( '(' ) )
                , UUParsing.pSym.apply1( new Character( ')' ) )
                ) ;

        // pRoot prios = let pExpr = prios (pNat <|> pParens pExpr) in pExpr
        pExpr = 
            new Function1()
            {
                public Object eval1( Object prios )
                {
                    Indirection ind_pExpr = new Indirection() ;
                    Eval pExpr = 
                        ((Eval)prios).apply1
                            ( UUParsing.pChoice.apply2
                                ( pNat
                                , pParens.apply1( ind_pExpr )
                                )
                            ) ;
                    ind_pExpr.set( pExpr ) ;
                    return pExpr ;
                }
            } ;

        // pAnyOp = pOp <$> pAnyOf "*+/-^"
        /*
        Eval pAnyOp =
            UUParsing.pApp.apply2
                ( pOp
                , UUParsing.pAnyOf.apply1( Str.valueOf( "*+/-^" ) )
                ) ;
        */
        
        // pAnyOps = pOps <$> pSome (pAnyOf "*+/-^")
        Eval pAnyOps =
            UUParsing.pApp.apply2
                ( pOps
                , UUParsing.pSome.apply1
                    ( UUParsing.pAnyOf.apply1( Str.valueOf( "*+/-^" ) )
                    )
                ) ;
        
        // pPrios = pParens $
        //          pFoldr ((.), id) ((  pChainl <$ pSym 'L'
        //                           <|> pChainr <$ pSym 'R') <*> pAnyOp)
        /*
        Eval pPrios =
            StdFuncs.apply.apply2
                ( pParens
                , UUParsing.pFoldr.apply2
                    ( new Tuple( StdFuncs.compose, StdFuncs.id )
                    , UUParsing.pSeq.apply2
                        ( UUParsing.pChoice.apply2
                            ( UUParsing.pAppL.apply2
                                ( UUParsing.pChainl
                                , UUParsing.pSym.apply1( new Character( 'L' ) )
                                )
                            , UUParsing.pAppL.apply2
                                ( UUParsing.pChainr
                                , UUParsing.pSym.apply1( new Character( 'R' ) )
                                )
                            )
                        , pAnyOp
                        )
                    )
                ) ;             
        */
        // pPrios = pParens $
        //          pFoldr ((.), id) (   (   pChainl <$ pSym 'L'
        //                               <|> pChainr <$ pSym 'R'
        //                               )
        //                           <*> pAnyOps
        //                           )
        pPrios =
            StdFuncs.apply.apply2
                ( pParens
                , UUParsing.pFoldr.apply2
                    ( new Tuple( StdFuncs.compose, StdFuncs.id )
                    , UUParsing.pSeq.apply2
                        ( UUParsing.pChoice.apply2
                            ( UUParsing.pAppL.apply2
                                ( UUParsing.pChainl
                                , UUParsing.pSym.apply1( new Character( 'L' ) )
                                )
                            , UUParsing.pAppL.apply2
                                ( UUParsing.pChainr
                                , UUParsing.pSym.apply1( new Character( 'R' ) )
                                )
                            )
                        , pAnyOps
                        )
                    )
                ) ;             
	}

	// Retrieve the value of an applet parameter
	public String getParameter(String key, String def) 
	{
		return isStandalone ? System.getProperty(key, def) :
			(getParameter(key) != null ? getParameter(key) : def);
	}

	// Get info on the applet parameters
	public String[][] getParameterInfo() 
	{
		return null;
	}

	// Get applet information
	public String getAppletInfo() 
	{
		return "Applet Information";
	}

	// Initialize the applet
	public void init() 
	{
		try {
			initComponents();
		}
		catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void initComponents() throws Exception
	{
// IMPORTANT: Source code between BEGIN/END comment pair will be regenerated
// every time the form is saved. All manual changes will be overwritten.
// BEGIN GENERATED CODE
		// the following code sets the frame's initial state
		labelPriorities.setText("Priorities:");
		labelPriorities.setLocation(new java.awt.Point(10, 30));
		labelPriorities.setVisible(true);
		labelPriorities.setSize(new java.awt.Dimension(60, 20));

		textAreaPriorities.setText("(L+-L*/)");
		textAreaPriorities.setLocation(new java.awt.Point(80, 30));
		textAreaPriorities.setVisible(true);
		textAreaPriorities.setSize(new java.awt.Dimension(130, 80));

		textAreaPrioErrors.setLocation(new java.awt.Point(220, 30));
		textAreaPrioErrors.setVisible(true);
		textAreaPrioErrors.setSize(new java.awt.Dimension(320, 80));
		textAreaPrioErrors.setEditable(false);

		labelErrors.setText("Errors:");
		labelErrors.setLocation(new java.awt.Point(220, 10));
		labelErrors.setVisible(true);
		labelErrors.setSize(new java.awt.Dimension(90, 20));

		labelExpression.setText("Expression:");
		labelExpression.setLocation(new java.awt.Point(10, 130));
		labelExpression.setVisible(true);
		labelExpression.setSize(new java.awt.Dimension(60, 20));

		textAreaExpression.setText("3*4-6");
		textAreaExpression.setLocation(new java.awt.Point(80, 130));
		textAreaExpression.setVisible(true);
		textAreaExpression.setSize(new java.awt.Dimension(130, 70));

		textAreaExprErrors.setLocation(new java.awt.Point(220, 130));
		textAreaExprErrors.setVisible(true);
		textAreaExprErrors.setSize(new java.awt.Dimension(320, 70));
		textAreaExprErrors.setEditable(false);

		labelTiming.setText("Timing:");
		labelTiming.setLocation(new java.awt.Point(10, 250));
		labelTiming.setVisible(true);
		labelTiming.setSize(new java.awt.Dimension(60, 20));

		textFieldTiming.setLocation(new java.awt.Point(80, 250));
		textFieldTiming.setVisible(true);
		textFieldTiming.setSize(new java.awt.Dimension(460, 30));
		textFieldTiming.setEditable(false);

		labelExprResult.setText("Result:");
		labelExprResult.setLocation(new java.awt.Point(10, 210));
		labelExprResult.setVisible(true);
		labelExprResult.setSize(new java.awt.Dimension(60, 20));

		textFieldExprResult.setLocation(new java.awt.Point(80, 210));
		textFieldExprResult.setVisible(true);
		textFieldExprResult.setSize(new java.awt.Dimension(130, 30));
		textFieldExprResult.setEditable(false);

		setLocation(new java.awt.Point(0, 0));
		setLayout(null);
		setSize(new java.awt.Dimension(550, 300));
		add(labelPriorities);
		add(textAreaPriorities);
		add(textAreaPrioErrors);
		add(labelErrors);
		add(labelExpression);
		add(textAreaExpression);
		add(textAreaExprErrors);
		add(labelTiming);
		add(textFieldTiming);
		add(labelExprResult);
		add(textFieldExprResult);


		textAreaPriorities.addTextListener(new java.awt.event.TextListener() {
			public void textValueChanged(java.awt.event.TextEvent e) {
				textAreaPrioritiesTextValueChanged(e);
			}
		});
		textAreaExpression.addTextListener(new java.awt.event.TextListener() {
			public void textValueChanged(java.awt.event.TextEvent e) {
				textAreaExpressionTextValueChanged(e);
			}
		});
// END GENERATED CODE
	}
	

	// Standard method to start the applet
	public void start() 
	{
		handleChangedPrios() ;
	}

	// Standard method to stop the applet
	public void stop() 
	{
	}

	// Standard method to destroy the applet
	public void destroy() 
	{
	}

	// Main entry point when running standalone
	public static void main(String[] args) 
	{
		PrioExprApplet applet = new PrioExprApplet();
		applet.isStandalone = true;
		Frame frame = new Frame();
		frame.setTitle("Applet Frame");
		frame.add( applet, BorderLayout.CENTER );
		applet.init();
		applet.start();
		frame.setSize( 550, 320 );
		Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
		frame.setLocation( (d.width - frame.getSize().width) / 2,
			(d.height - frame.getSize().height) / 2);
		frame.setVisible( true );
	}
	
	private void handleChangedExpr()
	{
	    resetTiming() ;
	    reEvalExpr() ;
	    setTiming() ;
	}
	
	private void handleChangedPrios()
	{
	    resetTiming() ;
	    reEvalPrios() ;
	    setTiming() ;
	}
	
	public void textAreaPrioritiesTextValueChanged(java.awt.event.TextEvent e)
	{
	    handleChangedPrios() ;
	}
	
	public void textAreaExpressionTextValueChanged(java.awt.event.TextEvent e)
	{
	    handleChangedExpr() ;
	}
	
	

}