import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.behaviors.vp.OrbitBehavior;
import com.sun.j3d.utils.geometry.GeometryInfo;
import com.sun.j3d.utils.geometry.Cylinder;
import com.sun.j3d.utils.geometry.Sphere;
import com.sun.j3d.utils.geometry.NormalGenerator;
import com.sun.j3d.utils.universe.*;
import javax.media.j3d.*;
import javax.vecmath.*;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.JLabel;


/**
 * Klasa główna 'Main' zawiera deklaracje zmiennych
 * @author
 */
public final class Main extends Applet implements KeyListener{

    final private static int Width = 900;
    final private static int Height = 600;
    final private OrbitBehavior obserwator;
    final private ViewingPlatform vPlatform;
    private RotationInterpolator punkt1; // arm sweep - baza robota
    private RotationInterpolator punkt2; // shoulder - ramie robota
    private RotationInterpolator punkt3;
    final private Timer zegar = new Timer();
    final private SimpleUniverse universe;
    private double x = 0.0f;
    private double y = 0.65f;
    private double z = 0.5f;
    private double x2 = 0.1f;
    private double y2 = 0.9f;
    private double z2 = 1.1f;
    JLabel label = new JLabel("Ramię Robota:");
    private TransformGroup objTrans;
    final private Transform3D trans = new Transform3D();
    private TransformGroup objTrans2;
    final private Transform3D trans2 = new Transform3D();
    private TransformGroup objTrans3;
    final private Transform3D trans3 = new Transform3D();
    private TransformGroup objTrans4;
    final private Transform3D trans4 = new Transform3D();
    private RotationInterpolator rotacja;
    final private Transform3D hujRotation = new Transform3D();

    /**
     * W metodzie tworzymy scenę oraz elementy, które będą w niej zawarte - tj.
     * elementy manipulatora cylindrycznego (cylinder, cylinder2, chwytak i przedmiot),
     * oświetlenie sceny oraz podłoże służące jako punkt odniesienia.
     * @return obiekt 'scena' typu BranchGroup
     */
    public BranchGroup createSceneGraph() {

       Alpha alpha1 = new Alpha(-1, 5000); // arm sweep

       BranchGroup scena = new BranchGroup(); // scena główna - swiatla, podloga
       BoundingSphere bounds = new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);

       Transform3D tmp = new Transform3D();


       objTrans = new TransformGroup();
       objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
       objTrans2 = new TransformGroup();
       objTrans2.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

       //statyw
       scena.addChild(objTrans);
       Cylinder cylinder1 = new Cylinder(0.1f, 1.5f);
       objTrans = new TransformGroup();
       objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
       Transform3D pos1 = new Transform3D();
       pos1.setTranslation(new Vector3f(0.0f, 0.25f, 0.0f));
       objTrans.setTransform(pos1);
       objTrans.addChild(cylinder1);
       //scena.addChild(objTrans);

       //ramie
       scena.addChild(objTrans2);
       Cylinder cylinder2 = new Cylinder(0.05f, 1.25f);
       objTrans2 = new TransformGroup();
       objTrans2.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
       Transform3D cyl2 = new Transform3D();
       tmp.set(new Vector3f(0.0f,0.0f,0.0f));
       cyl2.rotX(Math.PI/2);
       tmp.mul(cyl2);
       cyl2.setTranslation(new Vector3d(x, y, z));
       objTrans2.setTransform(cyl2);
       objTrans2.addChild(cylinder2);
       //scena.addChild(objTrans2);

       //kulka
       scena.addChild(objTrans3);
       Sphere chwytak = new Sphere(0.08f);
       objTrans3 = new TransformGroup();
       objTrans3.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
       Transform3D kulka = new Transform3D();
       kulka.setTranslation(new Vector3d(x2, y2, z2));
       objTrans3.setTransform(kulka);
       objTrans3.addChild(chwytak);
       scena.addChild(objTrans3);

       //kulka
       scena.addChild(objTrans4);
       Sphere przedmiot = new Sphere(0.1f);
       objTrans4 = new TransformGroup();
       objTrans4.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
       Transform3D kulka2 = new Transform3D();
       kulka2.setTranslation(new Vector3f(0.0f, 0.0f, 1.0f));
       objTrans4.setTransform(kulka2);
       objTrans4.addChild(przedmiot);
       scena.addChild(objTrans4);

       // podłoże
       Appearance ap = new Appearance();
       Color3f black = new Color3f(.0f,.0f,.0f);
       Color3f white = new Color3f(0.8f,.8f,.8f);
       ap.setMaterial(new Material(white,black,white,black,80f));
       podloga ob = new podloga();
       ob.setAppearance(ap);
       scena.addChild(ob);

       // światło kierunkowe
       Color3f light1Color = new Color3f(1.0f, 1.0f, 1.0f);
       Vector3f light1Direction = new Vector3f(4.0f, -7.0f, -12.0f);
       DirectionalLight light1 = new DirectionalLight(light1Color, light1Direction);
       light1.setInfluencingBounds(bounds);
       scena.addChild(light1);

       // światło
       Color3f ambientColor = new Color3f(1.0f, 1.0f, 1.0f);
       AmbientLight ambientLightNode = new AmbientLight(ambientColor);
       ambientLightNode.setInfluencingBounds(bounds);
       scena.addChild(ambientLightNode);

       //objTrans2.addChild(objTrans3);
       objTrans.addChild(objTrans2);
       scena.addChild(objTrans);



       scena.compile();
       return scena;
    }

    /**
     * Konstruktor bezparametrowy klasy 'Main'. Ustawia on wygląd okna programu
     * (BorderLayout()), tworzy w nim podstawowe obiekty Java3D (SimpleUniverse).
     * Ustawia pozycję i zachowanie kamery oraz uruchamia zegar.
     */
    public Main() {
        setLayout(new BorderLayout());

        GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();
        Canvas3D canvas3D = new Canvas3D(config);
        add("Center", canvas3D);
        canvas3D.addKeyListener(this);
        add("South",label);

        // Create a simple scene and attach it to the virtual universe
        BranchGroup scene = createSceneGraph();
        universe = new SimpleUniverse(canvas3D);
        universe.addBranchGraph(scene);
        obserwator = new OrbitBehavior(canvas3D);
        BoundingSphere bounds = new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);
        obserwator.setSchedulingBounds(bounds);
        vPlatform = universe.getViewingPlatform();
        Transform3D temp = new Transform3D();
        temp.set(new Vector3f(0f,0f,7.0f));
        vPlatform.getViewPlatformTransform().setTransform(temp);
        vPlatform.setViewPlatformBehavior(obserwator);
        zegar.scheduleAtFixedRate(new Ruch(), 20, 25);
    }

    /**
     * Funkcja tworzy okno typu MainFrame o zadanych wymiarach Width i Height.
     * Konstruktor okna wywołuje konstruktor klasy Main().
     * @param args
     */
    public static void main(String[] args) {
       //Main bb = new Main();
       MainFrame mf = new MainFrame(new Main(),Width, Height);
    }

   public static float round (double f)

   {  float temp = (float)(f*(Math.pow(10, 0)));

          temp = (Math.round(temp));

          temp = temp/(int)(Math.pow(10, 0));

          return temp;

   }
    /**
     * Funkcja wychwytuje zdarzenie wciśniecią przycisku na klawiaturze.
     * Zawiera obsługę przycisków służących do manipulacji robotem.
     * UP, DOWN     - przesuw ramienia w pionie
     * LEFT, RIGHT  - obrót ramienia wokół jego osi pionowej
     * A, S         - przesuw ramienia w poziomie (wysuwanie, wsuwanie)
     * Z            - standardowe ustawienie kamery
     * @param e (KeyEvent)
     */
    @Override
    public void keyPressed(KeyEvent e) {
        if(e.getKeyCode() == KeyEvent.VK_Z){
            vPlatform.setNominalViewingTransform();
        }
        if (Math.round(Math.toDegrees(x))==360) x=Math.toRadians(0);
        if (Math.toDegrees(x)==-1) x=Math.toRadians(358.9999999999974);
        switch(e.getKeyCode()){
            case KeyEvent.VK_UP:
                if(y < 0.65f) {
                    y += 0.05;
                    y2 += 0.05;
                }
                break;
            case KeyEvent.VK_DOWN:
                if(y > -0.6f) {
                    y -= 0.05;
                    y2 -= 0.05;
                }
                break;
            case KeyEvent.VK_LEFT:
                x -= Math.PI/180;
                break;
            case KeyEvent.VK_RIGHT:
                x += Math.PI/180;
                break;
            case KeyEvent.VK_A:
                if(z > -0.3f) {
                    z -= 0.05;
                    z2 -= 0.05;
                }
                break;
            case KeyEvent.VK_S:
                if(z < 0.5f) {
                    z += 0.05;
                    z2 += 0.05;
                }
                break;
        }
    }

    /**
     * Funkcja wychwytująca puszczenie przycisku klawiatury - nie używana.
     * @param e
     */
    @Override
    public void keyReleased(KeyEvent e){
    }

    /**
     * Funkcja wychwytująca sygnał przycisku klawiatury - nie używana.
     * @param e
     */
    @Override
    public void keyTyped(KeyEvent e){
    }


//    @Override
//    public void mouseMoved(MouseEvent e) {
//       // x = (float)(e.getX())/Width-.5f;
//        //y = -(float)(e.getY())/Height+.5f;
//    }

    /**
     * Klasa dziedzicząca po klasie TimerTask.
     * Zawiera funkcję run().
     */
    private class Ruch extends TimerTask{
        /**
         * Zadaniem funkcji jest przekształcanie
         * sceny w zależności od parametrów (zmienne globalne) oraz wyświetlanie
         * informacji o aktualnych wartościach parametrów w dolnym pasku
         * informacyjnym.
         */
        @Override
        public void run() {
            trans.rotX(Math.PI/2);
            trans.setTranslation(new Vector3d(0.1f, y, z));
            trans2.setTranslation(new Vector3d(0.1f,y2,z2));
            objTrans2.setTransform(trans);

            hujRotation.rotY(x);
            trans.mul(hujRotation, trans);
            trans2.mul(hujRotation, trans2);
            objTrans2.setTransform(trans);
            objTrans3.setTransform(trans2);
            label.setText("Współrzędne: " + Math.round(Math.toDegrees(x)) + " , "+ y + " , " + z);
        }
    }

    /**
     * Klasa 'podloga' dziedzicząca po klasie 'Shape3D'.
     */
    public class podloga extends Shape3D{ // podłoże robota
        final private Point3f A= new Point3f(-5.0f, -0.5f, -5.0f);
        final private Point3f B= new Point3f(-5.0f, -0.5f, 5.0f);
        final private Point3f C= new Point3f(5.0f, -0.5f, 5.0f);
        final private Point3f D= new Point3f(5.0f, -0.5f, -5.0f);
        final private Point3f[] pts = new Point3f[8];
        int[] stripCounts= new int[2];
        int[] contourCount=new int[2];

        /**
         * Konstruktor bezparametrowy klasy 'podloga'. Tworzy punkt odniesienia
         * dla manipulatora.
         */
        public podloga(){
            // front
            pts[0]=C;
            pts[1]=D;
            pts[2]=A;
            pts[3]=B;
            //back
            pts[4]=C;
            pts[5]=B;
            pts[6]=A;
            pts[7]=D;

            stripCounts[0]=4;
            stripCounts[1]=4;
            contourCount[0]=1;
            contourCount[1]=1;
            GeometryInfo gInf = new GeometryInfo(GeometryInfo.POLYGON_ARRAY);
            gInf.setCoordinates(pts);
            gInf.setStripCounts(stripCounts);
            gInf.setContourCounts(contourCount);
            NormalGenerator ng= new NormalGenerator();
            ng.setCreaseAngle ((float) Math.toRadians(30));
            ng.generateNormals(gInf);
            this.setGeometry(gInf.getGeometryArray());
            }
    }

}