import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.*;
import java.util.*;
import java.io.*;
import java.util.*;
import gl4java.GLContext;
import gl4java.awt.GLCanvas;

import gl4java.utils.glut.*;

public class ex3 extends Applet 
{
    exampleCanvas canvas = null;
    jooglRealTimeClock rtClock = null;
    
    /**
     * void init()
     *
     * Initialise the applet.
     */
    public void init()
    {
        Dimension d = getSize();

        //We will use BorderLayout to layout the applet components
        setLayout(new BorderLayout());

        //Create our canvas and add it to the center of the applet
        canvas = new exampleCanvas(d.width, d.height);
        add("Center", canvas);
        
        /* retrieve the root object */
        jooglRoot root = new jooglRoot();
        canvas.addRoot(root);
        rtClock = ((jooglRealTimeClock)(canvas.getClock()));

        /* create a camera */
        jooglCamera camera = 
            new jooglPerspectiveCamera(0.0, 0.0, 30.0, /* eye is at (0,0,30) */
	 		   0.0, 0.0, 0.0, /* center is at (0,0,0) */
			   0.0, 1.0, 0.0, /* up is in positive Y direction */
			   40.0, /* field of view in degree */ 
			   1.0, /* Z near */
			   100.0);/* Z far */
        root.setCamera(camera);
        
        root.setShadeMode(new jooglShadeMode(jooglShadeMode.SMOOTH));
        
        /* create an ambient light and add it to the scene graph. */
        jooglAmbientLight lightAmb = new jooglAmbientLight(0.2, 0.2, 0.2);
        root.add(lightAmb);
    
        /* First, create two groups, and set them to rotating about the Y and Z axes.
         * Add the top group to the root. */
        jooglGroup group1 = new jooglGroup();
        jooglGroup group3 = new jooglGroup();

        /* Add a group to the root. */
        root.add(group3);
        group3.add(group1);

        group3.setTransform(new jooglDynamicTransform() {
                public double[] getValue(long time)
                {
                    double ry = (time/3333.0)*360.0;
                    setIdentity();
                    rotateY(ry);
                    return matrix;
                }
            });
        group1.setTransform(new jooglDynamicTransform() {
                public double[] getValue(long time)
                {
                    double rz = (time/2000.0)*360.0;
                    setIdentity();
                    rotateZ(rz);
                    return matrix;
                }
            });

        /***********************
         * Create two point light sources, with little icons for them (small spheres)
         ***********************/

        /* Next add a small green sphere to group1, and translate it to (6,3,3) */
        jooglSphere sphere1 = new jooglSphere(0.5, 10);
        sphere1.setTransform(new jooglTransform().translate(6.0, 3.0, 3.0));
        sphere1.setMaterial(new jooglMaterial(0.2, 1.0, 0.2, 0.3));

        jooglPositionalLight light1 = 
            new jooglPositionalLight(0.6, 1.5, 0.4, /* green-tinted */
				   6.0, 3.0, 3.0, /* out on the x axis */
				   1.0, 0.5, 0.0);
        group1.add(sphere1);
        group1.add(light1);
        
        /* Next add a small green sphere to group1, and translate it to (6,3,3) */
        jooglSphere sphere2 = new jooglSphere(0.5, 10);
        sphere2.setTransform(new jooglTransform().translate(-6.0, -3.0, -3.0));
        sphere2.setMaterial(new jooglMaterial(1.0, 0.2, 0.2, 0.3));

        jooglPositionalLight light2 = 
            new jooglPositionalLight(1.5, 0.4, 0.6, /* red-tinted */
				   -6.0, -3.0, -3.0, /* out on the x axis */
				   1.0, 0.5, 0.0);
        group1.add(sphere2);
        group1.add(light2);
        
        /* create a group and add it to the root. */
        jooglGroup group2 = new jooglGroup();
	root.add(group2);
        
        /* create a simple sphere with some properties, and put it in the group. */
        jooglSphere sphere = new jooglSphere(3.0, 30);
        sphere.setMaterial(new jooglMaterial(1.0, 0.5, 1.0));
        
        sphere.setMaterial(new jooglDynamicMaterial() {
                public float[] getValue(long time)
                {
                    float[] m = new float[4];
                    long interval = 2000;
                    long sec = time/interval;
                    m[3] = 1.0f;
                    
                    // in the first second have red go 0.25 -> 0.75
                    if ((sec % 6) == 0)
                    {
                        m[0] = (time % interval)/(float)(interval*2) + 0.25f;
                        m[1] = 0.25f;
                        m[2] = 0.25f;
                    }
                    // in the second second have green go 0.25 -> 0.75
                    else if ((sec % 6) == 1)
                    {
                        m[0] = 0.75f;
                        m[1] = (time % interval)/(float)(interval*2) + 0.25f;
                        m[2] = 0.25f;
                    }
                    // in the third second have red go 0.75 -> 0.25
                    else if ((sec % 6) == 2)
                    {
                        m[0] = 0.75f - (time % interval)/(float)(interval*2);
                        m[1] = 0.75f;
                        m[2] = 0.25f;
                    }
                    // in the fourth second have blue go 0.25 -> 0.75
                    else if ((sec % 6) == 3)
                    {
                        m[0] = 0.25f;
                        m[1] = 0.75f;
                        m[2] = (time % interval)/(float)(interval*2) + 0.25f;
                    }
                    // in the fifth second have green go 0.75 -> 0.25
                    else if ((sec % 6) == 4)
                    {
                        m[0] = 0.25f;
                        m[1] = 0.75f - (time % interval)/(float)(interval*2);
                        m[2] = 0.75f;
                    }
                    // in the sixth second have blue go 0.75 -> 0.25
                    else 
                    {
                        m[0] = 0.25f;
                        m[1] = 0.25f;
                        m[2] = 0.75f - (time % interval)/(float)(interval*2);
                    }
                    //System.out.println((sec%6) + ": " + m[0] + "," + m[1] + "," + m[2]);
                    return m;
                }
            });

        group2.add(sphere);
        
        jooglGroup group4 = new jooglGroup();
        group4.setTransform(new jooglTransform().translate(0.0, -3.0, 0.0));
        group4.add(sphere);
        group2.add(group4);

        group4.setDrawMode(new jooglDynamicDrawMode() {
                public int getValue(long time)
                {
                    long sec = time/1000;
                    if ((sec % 3) == 0)
                    {
                        return jooglDrawMode.LINE;
                    }
                    else if ((sec % 3) == 1)
                    {
                        return jooglDrawMode.POINT;
                    }
                    else
                    {
                        return jooglDrawMode.FILL;
                    }
                }
            });

        jooglGroup group5 = new jooglGroup();
        group5.setTransform(new jooglTransform().translate(0.0, 3.0, 0.0));
        group5.add(sphere);
        group2.add(group5);

        group5.setShadeMode(new jooglDynamicShadeMode() {
                public int getValue(long time)
                {
                    long sec = time/500;
                    if ((sec % 2) == 0)
                    {
                        return jooglShadeMode.SMOOTH;
                    }
                    else
                    {
                        return jooglShadeMode.FLAT;
                    }
                }
            });


    }


    /**
     * void start()
     *
     * Start the applet.
     */
    public void start()
    {
    }


    /**
     * void stop()
     *
     * Stop the applet.
     */
    public void stop()
    {
    }

    /* main, for when it is run from the command line. 
     * Set up a window for the "applet" to run in.
     */
    public static void main( String args[] ) {
	ex3 applet = new ex3();

	Frame f = new Frame("CS4451A Joogl Example 3");
	f.addWindowListener( new WindowAdapter() {
		public void windowClosed(WindowEvent e)
		{
		    System.exit(0);
		}
		public void windowClosing(WindowEvent e)
		{
		    windowClosed(e);
		}
	    });

	f.setLayout(new BorderLayout());
	f.add("Center", applet);
	applet.setSize(500,300);
	applet.init();
	applet.start();
	Dimension ps = applet.getPreferredSize();
	f.setBounds(-100,-100,99,99);
	f.setVisible(true);
	f.setVisible(false);
	f.setVisible(true);
	Insets i = f.getInsets();
	f.setBounds(0,0, ps.width+i.left+i.right, 
		    ps.height+i.top+i.bottom);
	f.setVisible(true);
    }

    /* GLCanvas class for this application.     
     * We would use GLAnimCanvas because if we wanted the canvas
     * to be constantly redrawn.
     */
    private class exampleCanvas extends jooglCanvas implements MouseListener
    {
        public exampleCanvas(int w, int h)
        {
            super(w, h);
        }
    
        /**
         * void preInit()
         *
         * Called just BEFORE the GL-Context is created.
         */
        public void preInit()
        {
            // initialize joogl
            super.preInit();
        }
    
        /**
         * void init()
         *
         * Called just AFTER the GL-Context is created.
         */	
	public void init()
	{
            // initialize joogl
            super.init();
            //addMouseListener(this);
        }

        /*
	 * Methods required for the implementation of MouseListener
	 */
        public void mouseEntered(MouseEvent evt)
        {
        }
    
        public void mouseExited(MouseEvent evt)
        {
        }
    
        public void mousePressed(MouseEvent evt)
        {
        }
    
        public void mouseReleased(MouseEvent evt)
        {
	    int x1 = evt.getX();
	    int y1 = evt.getY();

            if (rtClock.isMoving())
                rtClock.stop();
            else
                rtClock.start();

            System.out.println("Toggled clock.");
	    repaint();
        }
    
        public void mouseClicked(MouseEvent evt)
        {
	}
    }
}