import java.awt.*;
import java.awt.event.MouseEvent;
import java.applet.*;
import java.net.*;
import java.util.*;
import java.io.*;
import java.lang.*;
import java.text.*;
class OutputWindow extends Frame implements Runnable{
    TextArea OutputBox = new TextArea();
    Button OKButton = new Button("OK");
    Button graphButton = new Button("View Graph");
    Label blank1 = new Label("",Label.LEFT);
    private int Degree;
    private double x[][];
    private double y[];
    private double Y[], z[];
    private double rms, Rsquared, MeanSquare, StandardDeviation,
                   correlation;
    private int nx, Ncards, Nparms, Imethod;
    private boolean Constant;
    private StringBuf0 out;     //use StringBuf0 for 1.0 compatibility; use StringBuf1 for 1.1 compatibility
    private reg theApplet;
    private Thread Printer=null;
    DataWindow Caller;

    OutputWindow(){}
    OutputWindow(String title, DataWindow Caller){
        super(title);
        this.Caller = Caller;
        theApplet = Caller.Caller; 
        init();
        DoLayout();
        //Printing in a text area could take long, so associate
        //a thread to that code to not interfere with parallel
        //interaction.
        if(Printer == null){
            Printer = new Thread(this);
            Printer.start();
        }
    }
    public synchronized void run(){
        if(theApplet.InApplet){
            theApplet.getAppletContext().showStatus("Writing output...");
        }
        while(Printer != null){
            hide(); validate();
            Print();
            show(); validate();
            if(theApplet.InApplet){
                theApplet.getAppletContext().showStatus("");
            }
            OutputBox.requestFocus();
            Printer = null;
        }
    }
    public final void DoLayout(){
        addNotify();
        resize(500, 300);
        OutputBox.setEditable(true);
        OutputBox.setFont(new Font ("Courier", Font.PLAIN, 12));
        OutputBox.setBackground(Color.white);
        OutputBox.setForeground(Color.black);
        OKButton.setFont(new Font ("Arial", Font.PLAIN, 12));
        OKButton.setBackground(Color.lightGray);
        OKButton.setForeground(Color.black);
        graphButton.setBackground(Color.lightGray);
        graphButton.setForeground(Color.black);
        this.setBackground(Color.magenta.darker());
        this.setForeground(Color.black);

        GridBagLayout gridbag = new GridBagLayout();
        GridBagConstraints constraints = new GridBagConstraints();
        setLayout(gridbag);

        //Row 1
        buildConstraints(constraints, 0, 0, 1, 1, 100, 80);
        constraints.fill = GridBagConstraints.BOTH;
        constraints.anchor = GridBagConstraints.CENTER;
        gridbag.setConstraints(OutputBox, constraints);
        add(OutputBox);

      //Blank card

        buildConstraints(constraints, 0, 1, 1, 1, 100, 5);
        constraints.fill = GridBagConstraints.NONE;
        constraints.anchor = GridBagConstraints.CENTER;
        gridbag.setConstraints(blank1, constraints);
        add(blank1);

        //Row 2
        buildConstraints(constraints, 0, 2, 2, 1, 100, 15);
        constraints.fill = GridBagConstraints.NONE;
        constraints.anchor = GridBagConstraints.CENTER;
        constraints.ipadx = 40;
        if( (Degree == 1) || (Imethod == 0) ){
            gridbag.setConstraints(graphButton, constraints);
            add(graphButton);
        }else{
            gridbag.setConstraints(OKButton, constraints);
            add(OKButton);
        }
    }
    public void buildConstraints(GridBagConstraints gbc, int gx, int gy,
                                 int gw, int gh, int wx, int wy){
        gbc.gridx = gx;
        gbc.gridy = gy;
        gbc.gridwidth = gw;
        gbc.gridheight = gh;
        gbc.weightx = wx;
        gbc.weighty = wy;
    }
    public Insets insets(){
        return new Insets(40, 15, 45, 15);
    }
    public void init()
    {
        Imethod = Caller.fit.getMethod();
        Degree = Caller.fit.getDegree();
        Constant = Caller.fit.isConstant();
        rms = Caller.fit.getRMS();
        Rsquared = Caller.fit.getRsquared();
        correlation = Caller.fit.getCorrelation();
        StandardDeviation = Caller.fit.getStandardDeviation();
        Ncards = Caller.fit.getN();
        nx = Caller.fit.getNx();
        x = new double[Ncards][nx];
        y = new double[Ncards];
        Y = new double[Ncards];
        x = Caller.fit.getX(); y = Caller.fit.getY(); 
        Y = Caller.fit.getYY();
        Nparms = Caller.fit.getNparms();
        z = new double[Nparms];
        z = Caller.fit.getParameters();
    }
    public void Print(){
        StringBuffer strBuf = new StringBuffer();
        //Write the output to a string buffer.
        out = new StringBuf0(strBuf); //use StringBuf0 for 1.0 compatibility; use StringBuf1 for 1.1 compatibility
        out.setFieldLength(16);
        out.setFractionDigits(6);
        out.setNmax(4);
//        out.setForceRightPadding(true);
//        out.setIshift(9);
//        out.setFieldLspaces(10);
        out.setindLshift(0);
        PrintParameters();
        PrintStats();
        out.dotted_line();
        //Flush the output to the text area.
        OutputBox.setText(strBuf.toString());
    }
    public void PrintStats()
    {
        int i, k, Len=0; String str1=null, str2=null, str3=null;

        if( (Degree == 1) || (Imethod == 0) ){
            out.printSpace(6); out.printSpace(1);
            for(i=0; i<51; i++)out.print("-");
            out.printLine();
            out.printSpace(3);
            str1 = strUtil.padString("Input X", 16);
            str2 = strUtil.padString("Input Y", 16);
            str3 = strUtil.padString("Estimated Y", 16);
            out.printSpace(6); out.printSpace(1);
            out.print(str1+str2+str3);
            out.printLine();
            out.printSpace(6); out.printSpace(1);
            for(i=0; i<51; i++)out.print("-");
            out.printLine();
        }else{
            str1 = "Input (X's, Y) and Y Estimate";
            out.CenterString(str1, true);
        }
           
        switch(Imethod){
        case 0:           //Polynome
            Len = 3;
            break;
        case 1:           //Linear
            Len = Degree + 2;
 	      break;
        default:
	      break;
        }  
        double v[] = new double[Len];
        switch(Imethod){
        case 0:      //Polynome
            for(i=0; i<Ncards; i++){
	          v[0] = x[i][0]; v[1] = y[i]; v[2] = Y[i];
	          out.printVec(v, 3, i+1);
            }
            break;
        case 1:     //Linear
            for(i=0; i<Ncards; i++){
	          for(k=0; k<Degree; k++)v[k] = x[i][k];
	          v[k++] = y[i]; v[k++] = Y[i];
	          out.printVec(v, k, i+1);
            }
	      break;
        default:
	      break;
        }
/*
        NumFormat nf = new NumFormat();
        nf.setFieldLength(13); nf.setFractionDigits(9);
        for(i=0; i<Ncards; i++){
            out.print(nf.format(y[i]) +"   " +nf.format(x[i][0]));
            out.printLine();
        }
*/

        out.printLine();
/*
        out.put_string(30, "RMS error = ");
        out.print(rms);
        out.printLine();
*/
        out.put_string(21, "Standard Deviation = ");
        if(Ncards > Nparms){
            out.print(StandardDeviation);
        }else{
            out.print("       Undefined");
        }
        out.printLine();
        out.put_string(30, "R-squared = ");
        out.print(Rsquared);
        out.printLine();
/*
        out.put_string(16, "Correlation Coefficient = ");
        out.print(Math.sqrt(Rsquared));
        out.printLine();
*/
    }
    public void PrintParameters()
    {
        int N, i, k; String strMethod=null, mess1=null, mess2=null;

        double b[] = new double[Nparms+1];
        if(!Constant){
            N = Nparms + 1;
            mess1 = " (Constant not computed)";
        }else{
            N = Nparms;
            mess1 = "";
        }
        out.dotted_line();
        String str[] = new String[N];
        switch(Imethod){
        case 0:     
            strMethod = "POLYNOMIAL";
            mess2 = " of X^i";
            for(k=0, i=Nparms-1; i>=0; i--)b[k++] = z[i];
            for(k=0, i=Degree;   i>=1; i--){
                str[k++] = strUtil.indexString("X^", i, 16);
            }
            str[k] = strUtil.padString("Constant", 16);
            if(!Constant){
                b[Nparms] = 0;
            }else{
                b[Nparms-1] = z[0];
            }
            break;
        case 1:
            strMethod = "LINEAR";
            mess2 = " of Xi";
            for(k=0, i=0; i<Degree; i++)b[k++] = z[i];
            for(k=0, i=0; i<Degree; i++){
                str[k++] = strUtil.indexString("X", i+1, 16);
            }
            str[k] = strUtil.padString("Constant", 16);
            if(!Constant){
                b[Nparms] = 0;
            }else{
                b[Nparms-1] = z[Nparms-1];
            }
	      break;
        default:
	      break;
        }
        out.CenterString(strMethod +" SMOOTHING OF DATA",true);
        out.put_string(5, "DEGREE = ");
        out.print(3, Degree); out.print(mess1);
        out.printLine(); out.printLine();
        out.CenterString("Expansion Coefficients" +mess2,true);
        out.printVec(b, str, N); 
        return;
    }
    public boolean action(Event e, Object arg){
        Object theSource; String label=null;

        theSource = e.target;
        if(theSource instanceof Button){
            label = ((Button)theSource).getLabel();
            if(label == "OK"){
                hide();
                //dispose();
                validate();
                return(true);
            }else if(label == "View Graph"){
//                hide();
                //dispose();
//                validate();
                new graphWindow(" Graph", this);
                return(true);
            }
        }
        return(false);
    }
    // Make sure that pressing on a button is handled in 
    // the same way as clicking on it (action event).
    public boolean keyDown(Event e, int key){
        Object theSource;
        theSource = e.target;
        if(key == Event.ENTER){
            if(theSource instanceof Button ){
                //Create an "ACTION_EVENT" associated with any
                //button (target=(Button)theSource) and post it here 
                //for processing.
                e = new Event((Button)theSource, Event.ACTION_EVENT, 
                    ((Button)theSource).getLabel());                
                //this.postEvent(e);
                postEvent(e);
                return(true);            
            }
        }
        return(false);
    }
    public boolean handleEvent(Event e){
        Object theSource; int id;
        theSource = e.target;

        id = e.id;
        switch(id){
        case(Event.WINDOW_DESTROY):
            hide();
            return(true);
        default:
            return super.handleEvent(e);
        } 
    }
//Accessor methods relevant to the current output window.
    //Return the method
    public int getMethod(){
        return(Imethod);
    }
    //Return the (linear or polynomial) degree
    public int getDegree(){
        return(Degree);
    }
    //Return the "compute constant" boolean variable
    public boolean isConstant(){
        return(Constant);
    }
    //Return Nb. of smoothing parameters
    public int getNparms(){
        return(Nparms);
    }
    //Return smoothing parameters
    public double[] getParameters(){
        return(z);
    }
    //Return Nb. of input cards
    public int getN(){
        return(Ncards);
    }
    //Return Nb. of x's/card
    public int getNx(){
        return(nx);
    }
    //Return input x array
    public double[][] GetX(){
        return(x);
    }
    //Return input y vector
    public double[] GetY(){
        return(y);
    }
    //Return output (fitted estimates) y vector
    public double[] getYY(){
        return(Y);
    }
    //Return rms statistic
    public double getRMS(){
        return(rms);
    }
    //Return correlation statistic
    public double getCorrelation(){
        return(correlation);
    }
    //Return R-squared statistic
    public double getRsquared(){
        return(Rsquared);
    }
    //Return residual mean square statistic
    public double getMeanSquare(){
        return(MeanSquare);
    }
    //Return residual standard deviation statistic
    public double getStandardDeviation(){
        return(StandardDeviation);
    }
//
}