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 java.util.Enumeration;
import javax.media.j3d.*;
import javax.vecmath.*;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.BoxLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.JButton;
import javax.swing.Box;
import javax.swing.JOptionPane;

/**
 * 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.0d;
    private double y = 0.65d;
    private double z = 0.5d;
    private double y2;
    private double z2;
    private boolean spacja = false;
    private boolean zatrzask = false;
    private boolean inCollision = false;
    private boolean raz = false;
    private TransformGroup objTrans;
    private TransformGroup objTrans2;
    private TransformGroup objTrans3;
    private TransformGroup objTrans4;
    final private Transform3D trans = new Transform3D();
    final private Transform3D trans2 = new Transform3D();
    final private Transform3D trans3 = new Transform3D();
    final private Transform3D trans4 = new Transform3D();
    final private Transform3D trans5 = new Transform3D();
    final private Transform3D commonRotation = new Transform3D();
    final private Transform3D temp = new Transform3D();
    JLabel label = new JLabel("Ramię Robota:");
    JPanel gui = new JPanel();
    JTextField tf1 = new JTextField(1);
    JTextField tf2 = new JTextField(1);
    JTextField tf3 = new JTextField(1);
    JLabel tf1_label = new JLabel("Położenie wokół osi Z");
    JLabel tf2_label = new JLabel("Położenie w pionie");
    JLabel tf3_label = new JLabel("Położenie w poziomie");
    JButton zapis = new JButton("Ustaw");


    /**
     * 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() {

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


       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);
       objTrans2.addChild(cylinder2);

       //kulka
       scena.addChild(objTrans3);
       Sphere chwytak = new Sphere(0.08f);
       objTrans3 = new TransformGroup();
       objTrans3.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
       objTrans3.addChild(chwytak);
       scena.addChild(objTrans3);

       //kulka
       scena.addChild(objTrans4);
       Appearance app = new Appearance();
       Material mat = new Material(
               new Color3f(.0f,.0f,.0f),
               new Color3f(.0f,.0f,.0f),
               new Color3f(0.4f,0.4f,0.4f),
               new Color3f(0.7f,0.7f,0.7f),
               64);
       app.setColoringAttributes(new ColoringAttributes(1.0f, 0.0f, 0.0f,ColoringAttributes.ALLOW_COLOR_WRITE|ColoringAttributes.SHADE_GOURAUD));
       app.setMaterial(mat);
       app.setCapability(app.ALLOW_COLORING_ATTRIBUTES_WRITE);
       app.setCapability(app.ALLOW_MATERIAL_WRITE);
       Sphere przedmiot = new Sphere(0.1f, app);
       objTrans4 = new TransformGroup();
       objTrans4.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
       Transform3D kulka2 = new Transform3D();
       kulka2.setTranslation(new Vector3f(1.0f, -0.4f, 0.0f));
       objTrans4.setTransform(kulka2);
       objTrans4.addChild(przedmiot);
       scena.addChild(objTrans4);

       // podłoże
       Appearance ap = new Appearance();
       ap.setMaterial(new Material(
               new Color3f(0.8f,.8f,.8f),
               new Color3f(.0f,.0f,.0f),
               new Color3f(0.8f,.8f,.8f),
               new Color3f(.0f,.0f,.0f),
               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);

        // Create a new Behavior object that will perform the collision
        // detection on the specified object, and add it into
        // the scene graph.
        CollisionDetector cd = new CollisionDetector(przedmiot);
        BoundingSphere boundy = new BoundingSphere(new Point3d(0.0, 0.0, 0.0),
            1.0);
        cd.setSchedulingBounds(boundy);
        objTrans3.addChild(cd);

       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);

        add("East", gui);
        gui.setLayout(new BoxLayout(gui, BoxLayout.Y_AXIS));
        Box left = Box.createVerticalBox();
        Box right = Box.createVerticalBox();
        Box top = Box.createHorizontalBox();
        tf1.setMaximumSize(new Dimension(150, tf1.getPreferredSize().height));
        tf2.setMaximumSize(new Dimension(150, tf2.getPreferredSize().height));
        tf3.setMaximumSize(new Dimension(150, tf3.getPreferredSize().height));
        zapis.setPreferredSize(new Dimension(150, zapis.getPreferredSize().height));
        left.add(tf1_label);
        left.add(Box.createVerticalStrut(10));
        left.add(tf2_label);
        left.add(Box.createVerticalStrut(10));
        left.add(tf3_label);
        right.add(tf1); tf1.setText("0");
        right.add(Box.createVerticalStrut(10));
        right.add(tf2); tf2.setText("0.65");
        right.add(Box.createVerticalStrut(10));
        right.add(tf3); tf3.setText("0.5");

        top.add(left);
        top.add(right);
        gui.add(Box.createVerticalStrut(15));
        gui.add(top, BorderLayout.CENTER);
        gui.add(Box.createVerticalStrut(15));
        gui.add(zapis);

        zapis.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent evt) {
                double xt, yt, zt;

                //xt = Math.round(Math.toDegrees(Double.parseDouble(tf1.getText())));
                xt = (Math.PI/180*Double.parseDouble(tf1.getText()));
                yt = Double.parseDouble(tf2.getText());
                zt = Double.parseDouble(tf3.getText());

                if(xt>360 || xt<0) {
                    JOptionPane.showMessageDialog(null, "Niepoprawna wartość x\n"
                            + "Musi zawierać się w 0<=x<=360");
                } else {
                    x = xt;
                }

                if(yt>0.65 || yt<-0.65) {
                    JOptionPane.showMessageDialog(null, "Niepoprawna wartość y\n"
                            + "Musi zawierać się w -0.65<=y<=0.65");
                } else {
                    y = yt;
                }
                if(zt>0.5 || zt<-0.3) {
                    JOptionPane.showMessageDialog(null, "Niepoprawna wartość z\n"
                            + "Musi zawierać się w -0.3<=z<=0.5");
                } else {
                    z = zt;
                }

            }
        });

        // 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);
    }

/******************************************************************************/

  class CollisionDetector extends Behavior {
  private final Color3f highlightColor = new Color3f(0.0f, 1.0f, 0.0f);

  private final ColoringAttributes highlight = new ColoringAttributes(
      highlightColor, ColoringAttributes.SHADE_GOURAUD);

  final private Sphere sferka;
  final private ColoringAttributes shapeColoring;
  final private Appearance shapeAppearance;
  private WakeupOnCollisionEntry wEnter;
  private WakeupOnCollisionExit wExit;

  public CollisionDetector(Sphere s) {
    sferka = s;
    shapeAppearance = sferka.getAppearance();
    shapeColoring = shapeAppearance.getColoringAttributes();
    inCollision = false;
  }

  @Override
  public void initialize() {
    wEnter = new WakeupOnCollisionEntry(sferka);
    wExit = new WakeupOnCollisionExit(sferka);
    wakeupOn(wEnter);
  }

  @Override
  public void processStimulus(Enumeration criteria) {
    inCollision = !inCollision;

    if (inCollision) {
      shapeAppearance.setColoringAttributes(highlight);
      wakeupOn(wExit);
    } else {
      shapeAppearance.setColoringAttributes(shapeColoring);
      wakeupOn(wEnter);
    }
  }
  }

/******************************************************************************/
   /**
    *
    * @param f
    * @return
    */
   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)==0) x=Math.toRadians(359.9999999999974);
        switch(e.getKeyCode()){
            case KeyEvent.VK_UP:
                if(y < 0.65f) {
                    y += 0.05;
                }
                break;
            case KeyEvent.VK_DOWN:
                if(y > -0.6f) {
                    y -= 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;
                }
                break;
            case KeyEvent.VK_S:
                if(z < 0.5f) {
                    z += 0.05;
                }
                break;
            case KeyEvent.VK_SPACE:
                spacja = !spacja;
                zatrzask = true;
                break;
        }
    }

    /**
     * Funkcja wychwytująca puszczenie przycisku klawiatury - nie używana.
     * @param e
     */
    @Override
    public void keyReleased(KeyEvent e){
        switch(e.getKeyCode()){
            case KeyEvent.VK_SPACE:
                zatrzask = false;
                raz=true;
                break;
            case KeyEvent.VK_UP:
            case KeyEvent.VK_DOWN:
            case KeyEvent.VK_LEFT:
            case KeyEvent.VK_RIGHT:
            case KeyEvent.VK_A:
            case KeyEvent.VK_S:
                tf1.setText(Math.round(Math.toDegrees(x)) + "");
                tf2.setText(y + "");
                tf3.setText(z + "");
                break;
        }
    }

    /**
     * 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() {
            commonRotation.rotY(x);

            trans2.rotX(Math.PI/2);
            trans2.setTranslation(new Vector3d(0.0f, y, z));
            trans2.mul(commonRotation, trans2);
            objTrans2.setTransform(trans2);

            trans3.setTranslation(new Vector3d(0.0f,y+0.25,z+0.6));
            trans3.mul(commonRotation, trans3);
            objTrans3.setTransform(trans3);

            trans4.setTranslation(new Vector3d(0.0f, y+0.25, z+0.64));
            trans4.mul(commonRotation, trans4);

            if(raz&&!spacja&&inCollision){
                raz=false;

                temp.rotY(x);
                y2=y;
                z2=z;
            }

            if (y2>-0.3){
                y2-=0.01;
            }

            trans5.setTranslation(new Vector3d(0.0f, y2, z2+0.6f));
            trans5.mul(temp, trans5);
            if (spacja&&inCollision) {
                objTrans4.setTransform(trans4);
            }
            else {
                objTrans4.setTransform(trans5);
            }

            if (spacja&&inCollision) {
                objTrans4.setTransform(trans4);
            }

            if(spacja) {
                if(inCollision) {
                    label.setText("Chwytak: aktywny;    Przedmiot: chwycony");
                } else {
                    label.setText("Chwytak: aktywny;    Przedmiot: swobodny");
                }
            } else {
                label.setText("Chwytak: nieaktywny");
            }
        }
    }

    /**
     * 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());
            }
    }

}