/**
 * this sketch was a first test for the creatures hunting behavior.
 */


import java.io.InputStream;
import java.util.ArrayList;

import gestalt.Gestalt;
import gestalt.model.Model;
import gestalt.model.ModelData;
import gestalt.model.ModelLoaderOBJ;
import gestalt.model.ModelPlayer;
import gestalt.p5.GestaltPlugIn;
import gestalt.shape.Mesh;
import gestalt.util.CameraMover;

import mathematik.Vector3f;

import verhalten.Engine;
import verhalten.IVerhaltenEntity;
import verhalten.Rotation;
import verhalten.Seek;
import verhalten.Separation;
import verhalten.Wander;
import verhalten.view.JoglEngineView;
import verhalten.view.JoglSeekView;
import verhalten.view.JoglSeparationView;

import processing.opengl.*;


public class PredatorPrey

    extends PApplet implements Gestalt {

    private GestaltPlugIn gestalt;

    private ArrayList _myPrey;

    private Predator _myPredator;

    private int _myNumberOfTags;

    private float _myTimeSinceLastTag;

    private ModelPlayer _myModelPlayer;

    private Model _myModel;

    public void setup() {
        /* setup p5 */
        size(640, 480, OPENGL);
        framerate(50);
        rectMode(CENTER);
        noStroke();

        /* setup gestalt */
        gestalt = new GestaltPlugIn(this);
        gestalt.framesetup().depthbufferclearing = true;

        /* setup prey */
        int myNumberOfPrey = 10;
        _myPrey = new ArrayList();
        for (int i = 0; i < myNumberOfPrey; i++) {
            _myPrey.add(new Prey());
            Prey myPrey = (Prey) _myPrey.get(i);
            gestalt.bin(BIN_3D).add(myPrey.getView());
        }

        /* setup predator model */
        _myPredator = new Predator();

        /* load model */
        InputStream myModelStream = openStream("data/gulphog.obj");
        ModelData myModelData = ModelLoaderOBJ.getModelData(myModelStream);
        Mesh myModelMesh = gestalt.drawablefactory().mesh(false,
                                                          myModelData.vertices, 3,
                                                          myModelData.vertexColors, 4,
                                                          myModelData.texCoordinates, 2,
                                                          myModelData.normals,
                                                          myModelData.primitive);
        _myModel = gestalt.drawablefactory().model(myModelData, myModelMesh);
        _myModel.getView().rotation().set( PI_HALF, PI_HALF, 0);
        _myModel.getView().transform().translation = _myPredator.engine.transform().translation;
        _myModel.getView().transform().rotation = _myPredator.engine.transform().rotation;
        _myModelPlayer = new ModelPlayer(_myModel);
        _myModelPlayer.play(1);
        _myModelPlayer.setLooping(true);
        gestalt.bin(BIN_3D).add(_myModel);
    }


    public void draw() {
        /* clear screen */
        background(50);

        float myDeltaTime = 1 / 50f;
        CameraMover.handleKeyEvent(gestalt.camera(), gestalt.event(), myDeltaTime);

        /* score */
        _myTimeSinceLastTag += myDeltaTime;

        for (int i = 0; i < _myPrey.size(); i++) {
            Prey myPrey = (Prey) _myPrey.get(i);
            myPrey.loop(myDeltaTime);
        }

        /* predator */
        _myPredator.loop(myDeltaTime);
        _myModelPlayer.play(_myPredator.engine.velocity().length() / 50.0f);
        _myModelPlayer.loop(myDeltaTime);
    }


    private void teleport(Engine theEngine) {
        /* teleport */
        if (theEngine.position().x > width) {
            theEngine.position().x = 0;
        }
        if (theEngine.position().x < 0) {
            theEngine.position().x = width;
        }
        if (theEngine.position().y > height) {
            theEngine.position().y = 0;
        }
        if (theEngine.position().y < 0) {
            theEngine.position().y = height;
        }
    }


    private class Predator {

        private Engine engine;

        private Seek _mySeek;

        private JoglEngineView _myView;

        private Rotation _myRotation;

        public Predator() {
            /* setup engine */
            engine = new Engine();
            engine.setMaximumForce(500.0f);
            engine.setMaximumSpeed(130.0f);
            engine.velocity().set(random( -0.5f, 0.5f), random( -0.5f, 0.5f));
            engine.position().x = 640 * 0.33f;

            /* setup behavior */
            _mySeek = new Seek();

            /* setup view */
            _myView = new JoglEngineView(engine);
            _myView.material().getColor().set(0, 0.5f, 1);
            _myView.addBehavior(new JoglSeekView(_mySeek));

            /* setup rotation */
            _myRotation = new Rotation();
        }


        public JoglEngineView getView() {
            return _myView;
        }


        public void loop(float theDeltaTime) {
            /* find closest prey */
            Prey myClosestPrey = null;
            float myClosestDistance = Float.MAX_VALUE;

            for (int i = 0; i < _myPrey.size(); i++) {
                Prey myPrey = (Prey) _myPrey.get(i);
                float myDistanceToPrey = myPrey.engine.position().distance(engine.position());
                if (myDistanceToPrey < myClosestDistance) {
                    myClosestPrey = (Prey) _myPrey.get(i);
                    myClosestDistance = myDistanceToPrey;
                }
            }

            /* seek */
            Vector3f mySeparation = new Vector3f();
            if (myClosestPrey != null) {
                _mySeek.setPoint(myClosestPrey.engine.position());
                _mySeek.get(engine,
                            mySeparation);
                /* tagged */
                if (engine.position().distance(myClosestPrey.engine.position()) <
                    engine.getBoundingRadius() + myClosestPrey.engine.getBoundingRadius()) {
                    _myPrey.remove(myClosestPrey);
                    gestalt.bin(BIN_3D).remove(myClosestPrey.getView());
                    _myNumberOfTags++;
                }
            }

            engine.apply(theDeltaTime, mySeparation);
            teleport(engine);

            _myRotation.setRotationMatrix(engine.velocity(), engine.transform());
        }
    }


    private class Prey {

        public Engine engine;

        private Separation _mySeparation;

        private Wander _myWander;

        private JoglEngineView _myView;

        public Prey() {
            /* engine */
            engine = new Engine();
            engine.setMaximumForce(200.0f);
            engine.setMaximumSpeed(70.0f);
            engine.velocity().set(random( -0.5f, 0.5f), random( -0.5f, 0.5f));
            //engine.position().x = 640 * 0.66f;

            /* behavior */
            _mySeparation = new Separation();
            _mySeparation.setPrivacyRadius(200);
            _myWander = new Wander();
            _myWander.setRadius(10);

            /* setup view */
            _myView = new JoglEngineView(engine);
            _myView.material().getColor().set(1, 1, 1);
            _myView.addBehavior(new JoglSeparationView(_mySeparation));
        }


        public JoglEngineView getView() {
            return _myView;
        }


        public void loop(float theDeltaTime) {
            Vector3f mySeparation = new Vector3f();
            Vector3f myWanderDirection = new Vector3f();
            _mySeparation.get(new IVerhaltenEntity[] {_myPredator.engine},
                              engine.position(),
                              mySeparation);
            if (mySeparation.lengthSquared() == 0) {
                _myWander.get(engine, theDeltaTime, myWanderDirection);
            }

            mySeparation.add(myWanderDirection);

            engine.apply(theDeltaTime, mySeparation);
            teleport(engine);
        }

    }


    public static void main(String[] args) {
        PApplet.main(new String[] {"PredatorPrey"});
    }
}