/**
 * Created by IntelliJ IDEA.
 * User: siddhartha
 * Date: Jan 29, 2006
 * Time: 9:55:16 PM
 * To change this template use File | Settings | File Templates.

/*\\\\\\\\\\\\\\\\\\\\\\\\\\\\\////////////////////////////*\
This class is an extention of Canvas. Runs its own thread.
paint methods cannot be called directly by browser (good)
\*\\\\\\\\\\\\\\\\\\\\\\\\\\\\\////////////////////////////*/

import java.awt.*;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.text.DecimalFormat;

//! @brief This class measures various quantities of interest and displays or plots them on screen.

/// Not fully functional yet. Currently only measures average Delta-F or simply F. Can be used to measure other quantities,
/// Energy, for example. Maybe Friction?
class Measure extends Canvas implements Runnable {
    private Thread myThread;
    private AFMSimulator afmSim;
    private BufferedImage image;
    private Color backgroundColor;
    private Color textColor;
    private int ind;
    private final int W = 500, H = 300;
    private int delay = 100;
    private char what;       // measuring what? F = Force, R = Friction, L = Liapunov, etc.
    private boolean plot = true;    // plot or numerics?
    private final int X_AXIS = H/2;
    private final int Y_AXIS = W/2;
    private int zoom = 5000000;
    private DataQueue dataQueue, avgQueue;
    private String lastInfo = "";
    private int prevY = 0;
    private char delta;


    public Measure() {
        setSize(W, H);
        afmSim = new AFMSimulator();
        afmSim.setParams(AFMApplet.params[0], AFMApplet.params[1], AFMApplet.params[2], AFMApplet.params[3], AFMApplet.params[4], AFMApplet.params[5], AFMApplet.params[6], AFMApplet.params[7], AFMApplet.params[8]);
        afmSim.resetSim();
        image = new BufferedImage(W, H, BufferedImage.TYPE_INT_RGB);
        backgroundColor = AFMConstants.BG_color;
        textColor= AFMConstants.text_color;
        Graphics back = image.getGraphics();
        back.setColor(backgroundColor);
        back.fillRect(0, 0, W, H);
        back.setColor(textColor);
        what = 'F';       // defaults to Force
        delta = (char)(0*4096 + 3*256 + 9*16 + 4); // Unicode for delta is &#0394 (hexadecimal)
        back.drawString(measuring(what), 400, 20);
        addMouseMotionListener(new MouseCoordListener());
        addMouseListener(new MouseCoordListener());
        ind = 0;
        dataQueue = new DataQueue();
        avgQueue = new DataQueue();
    }

    public Measure(int _delay) {
        this();
        delay = _delay;
    }

    public void start() {
        if (myThread != null) stop();
        myThread = new Thread(this);
        myThread.start();
        drawAxes(true);
    }//end start

    public void reset() {
        image = new BufferedImage(W, H, BufferedImage.TYPE_INT_RGB);
        Graphics back = image.getGraphics();
        back.setColor(backgroundColor);
        back.fillRect(0, 0, W, H);
        back.setColor(textColor);
        back.drawString(measuring(what), 400, 20);

        ind = 0;
        dataQueue.empty(); avgQueue.empty();
        afmSim.setParams(AFMApplet.params[0], AFMApplet.params[1], AFMApplet.params[2], AFMApplet.params[3], AFMApplet.params[4], AFMApplet.params[5], AFMApplet.params[6], AFMApplet.params[7], AFMApplet.params[8]);
        afmSim.resetSim();
    }

    public void resume() {
        start();
    }

    public void run() {
        while (myThread != null) {
            repaint();
            try {
                Thread.sleep(delay);
            }
            catch (InterruptedException e) {
                this.stop();
            }
        }
    }//end run

    public void stop() {
        myThread = null;
    }

    public void cleanup() {
        myThread = null;
        afmSim = null;
        image = null;
        backgroundColor = null;
        textColor = null;
    }

    public AFMSimulator getState() {
        return afmSim;
    }

    public void clear() {
        Graphics back = image.getGraphics();
        back.setColor(backgroundColor);
        back.fillRect(0, 0, W, H);
        back.setColor(textColor);
    }

    public void switchDisplay() {
        clear();
        if(plot) plot = false;
        else plot = true;
    }

    public void drawAxes(boolean show) {
        double x_max = (double) (W - W / 2) * Surface.L / W;        // x_center holds *actual* x center value (in the system, not on the display)
        double y_max = (double) (X_AXIS - 0) / zoom;
        Color axes_color;
        if(show) axes_color = AFMConstants.axes_color;
        else axes_color = backgroundColor;

        AFMApplet.drawAxes(image, X_AXIS, Y_AXIS, "x", "F", x_max, y_max, zoom, axes_color);

    }

    public String measuring(char what) {
        if(what == 'F') return "Avg. " + delta + "F";
        if(what == 'R') return "Friction";
        if(what == 'E') return "Energy";
        else return "Patience";
    }

    public void measure(char what) {
        this.what = what;
    }

    public void update(Graphics g) {
        paint(g);
    }

    public void paint(Graphics g) {
        Graphics back = image.getGraphics();
        back.setColor(AFMConstants.terminal_color);
        double[][] roots = afmSim.getRoots();

        for(int i=0; i<afmSim.numRoots(); i++) {
            dataQueue.enqueue( Calculate.delta('F', afmSim, i) );
            if( dataQueue.isFull() ) {
                double avg = Calculate.average(dataQueue.getContents());
                avgQueue.enqueue(avg);
                if (!plot) {
                    back.setColor(AFMConstants.terminal_color);
                    back.drawString("Average " + delta + "F = " + Double.toString(avg), 10, 200);
                    g.drawImage(image, 0, 0, this);
                    back.setColor(backgroundColor);
                    back.drawString(lastInfo, 20, 270);

                    BufferedImage image2 = image.getSubimage(0,10,W,H-10);
                    back.drawImage(image2, 0, -10, this);
                    back.setColor(AFMConstants.info_color);
                    back.drawString(lastInfo, 20, 270);
                }
                dataQueue.dequeue();
            }
        }


        if ( plot ) {
            back.setColor(textColor);
            back.drawString(measuring(what), 400, 20);
            drawAxes(true);
            back.setColor(AFMConstants.info_color);
            back.drawString("Time = " + ind, 20, 290);
            back.setColor(AFMConstants.info_color);
            g.drawImage(image, 0, 0, this);
            int prevX = (int)(W * 0.95); // W+1 * .9?
            while(!avgQueue.isEmpty()) {       // empty it, then, plotting everything one at a time

                back.setColor(backgroundColor);
                back.drawString(lastInfo, 20, 270);
                back.drawString(measuring(what), 400, 20);
                drawAxes(false);
                back.drawString("Time = " + ind, 20, 290);

                BufferedImage image2 = image.getSubimage(25, 0, W-25, H);
                back.drawImage(image2, 0, 0, this);
                back.fillRect(475,0,25,H);

                back.setColor(AFMConstants.info_color);
                back.drawString(lastInfo, 20, 270);
                back.setColor(textColor);
                back.drawString(measuring(what), 400, 20);
                drawAxes(true);
                back.setColor(AFMConstants.info_color);
                back.drawString("Time = " + ind, 20, 290);

                int yCoord = X_AXIS - (int) Math.round(avgQueue.dequeue() * zoom);
                double x_realValue = (double) (prevX - W / 2) * Surface.L / W;        // x_center holds *actual* x center value (in the system, not on the display)
                if(x_realValue < 0) x_realValue += 1;
                double y_realValue = (double) (X_AXIS - yCoord) / zoom;
                back.drawOval(prevX-2, prevY-2, 4, 4);
                back.drawLine(prevX, prevY, W, yCoord);
                g.drawImage(image, 0, 0, this);
                prevY = yCoord;
            }
        }// if (plot)
        afmSim.getMore();
        ind++;


/*        else {
            back.setColor(textColor);
            back.drawString(measuring(what), 400, 20);
            drawAxes();
            back.setColor(AFMConstants.info_color);
            back.drawString("Time = " + ind, 20, 290);
            for (int j = 0; j < AFMConstants.SAMPLES; j += 5) {
                back.setColor(new Color(0xFF00 + j * 0xFF)); // gives nice colors. On every iteration,
                // the same indices have the same color
                int xCoord = (int) (W / 2 + AFMMath.mod(afmSim.getAFM().getX(j), Surface.L) * (double) W / (Surface.L));
                if (xCoord >= W) xCoord -= W;
                //***Changed this... experimenting with Force. Change back to getY(j)***\//
                double mag = Calculate.magnitude(afmSim.getAFM().getFX(j), afmSim.getAFM().getFY(j));
                int yCoord = X_AXIS - (int) Math.round(mag * zoom);
                /***workin' all the way ***\/
                double x_realValue = (double) (xCoord - W / 2) * Surface.L / W;        // x_center holds *actual* x center value (in the system, not on the display)
                if(x_realValue < 0) x_realValue += 1;
                double y_realValue = (double) (X_AXIS - yCoord) / zoom;
                back.drawOval(xCoord, yCoord, 1, 1);
            }
            g.drawImage(image, 0, 0, this);

            //*** Clear old values ***\/
            back.setColor(backgroundColor);
            for (int j = 0; j < AFMConstants.SAMPLES; j += 5) {
                int xCoord = (int) (W / 2 + AFMMath.mod(afmSim.getAFM().getX(j), Surface.L) * (double) W / (Surface.L));
                double mag = Calculate.magnitude(afmSim.getAFM().getFX(j), afmSim.getAFM().getFY(j));
                int yCoord = X_AXIS - (int) Math.round(mag * zoom);
                if (xCoord >= W) xCoord -= W;
                back.drawOval(xCoord, yCoord, 1, 1);
            }
            back.drawString("Time = " + ind, 20, 290);
            afmSim.getMore();
            ind++;
        }*/
    }//end paint


    private class MouseCoordListener implements MouseMotionListener, MouseListener {

        public void mouseDragged(MouseEvent e) {
            //To change body of implemented methods use File | Settings | File Templates.
        }

        public void mouseMoved(MouseEvent event) {
            Graphics back = image.getGraphics();
            double x = event.getPoint().getX();
            double y = event.getPoint().getY();
            double x_realValue = (double) (x - W / 2) * Surface.L / W;        // x_center holds *actual* x center value (in the system, not on the display)
            if(x_realValue > 1) x_realValue -= 1;
            double y_realValue = (double) (X_AXIS - y) / zoom;
            back.setColor(backgroundColor);
            back.drawString(lastInfo, 20, 270);
            DecimalFormat dec = new DecimalFormat("0.###");
            dec.setMaximumFractionDigits((int)Math.round(AFMMath.log2(zoom/100)) + 4);
            back.setColor(AFMConstants.info_color);
            lastInfo = "(" + dec.format(x_realValue) + ", " + dec.format(y_realValue) + ")";
            back.drawString(lastInfo, 20, 270);
            /***ADD CODE HERE***/
        }

        public void mouseClicked(MouseEvent event) {
            if(AFMApplet.zoomTool.isSelected()) {
                if (event.getButton() == MouseEvent.BUTTON1)
                    zoom *= 2;
                else
                    zoom /= 2;
                if(zoom<1) zoom = 1;
                clear();
                repaint();
            }
        }


        public void mouseEntered(MouseEvent e) {
            //To change body of implemented methods use File | Settings | File Templates.
        }

        public void mouseExited(MouseEvent e) {
            //To change body of implemented methods use File | Settings | File Templates.
        }

        public void mousePressed(MouseEvent e) {
            //To change body of implemented methods use File | Settings | File Templates.
        }

        public void mouseReleased(MouseEvent e) {
            //To change body of implemented methods use File | Settings | File Templates.
        }
    }
}//end Measure