package hello;

import com.jme3.app.SimpleApplication;
import com.jme3.font.BitmapText;
import com.jme3.input.KeyInput;
import com.jme3.input.controls.ActionListener;
import com.jme3.input.controls.AnalogListener;
import com.jme3.input.controls.KeyTrigger;
import com.jme3.light.AmbientLight;
import com.jme3.light.DirectionalLight;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;
import com.jme3.post.FilterPostProcessor;
import com.jme3.post.filters.FXAAFilter;
import com.jme3.post.ssao.SSAOFilter;
import com.jme3.renderer.queue.RenderQueue.ShadowMode;
import com.jme3.scene.Geometry;
import com.jme3.scene.Node;
import com.jme3.scene.shape.Box;
import com.jme3.shadow.PssmShadowRenderer;
import com.jme3.system.AppSettings;

public class HelloSingleFPP extends SimpleApplication {

    public static void main(String[] args) {
        AppSettings settings = new AppSettings(true);
        settings.setResolution(800, 600);
        settings.setTitle(HelloSingleFPP.class.getSimpleName());
        settings.setSamples(0);
        settings.setFrameRate(60);

        HelloSingleFPP app = new HelloSingleFPP();
        app.app = app; // i know, right?
        app.setShowSettings(false);
        app.setSettings(settings);
        app.setPauseOnLostFocus(false);
        app.start();
    }

    private HelloSingleFPP app;
    private float speedX = 0.1f, speedY = 0.1f;
    private Vector3f lightDirection = new Vector3f(-.5f, -.5f, -.5f);

    private PssmShadowRenderer pssmRenderer;
    private FilterPostProcessor fpp;
    private FXAAFilter fxaaFilter;
    private SSAOFilter ssaoFilter;
    private boolean useFXAA = false, useSSAO = false;

    private String postInfo = "";
    private BitmapText postText;

    @Override
    public void simpleInitApp() {
        setupCamera();
        setupFont();
        setupKeys();
        setupFloor();
        setupBox();
        setupLights();
        setupPost();
    }

    private void setupCamera() {
        flyCam.setEnabled(false);
        inputManager.removeListener(flyCam);

        final RtsCam rtsCam = new RtsCam(cam, rootNode);
        rtsCam.registerWithInput(inputManager);
        rtsCam.setCenter(new Vector3f(0f, 0f, 0f));
    }

    private void setupFont() {
        guiNode.detachAllChildren();
        guiFont = assetManager.loadFont("Interface/Fonts/Console.fnt");
        postText = new BitmapText(guiFont, false);
        postText.setSize(guiFont.getCharSet().getRenderedSize());
        updatePostInfo();
        guiNode.attachChild(postText);
    }

    private void setupKeys() {
        inputManager.addMapping("Left", new KeyTrigger(KeyInput.KEY_LEFT));
        inputManager.addMapping("Right", new KeyTrigger(KeyInput.KEY_RIGHT));
        inputManager.addMapping("Up", new KeyTrigger(KeyInput.KEY_UP));
        inputManager.addMapping("Down", new KeyTrigger(KeyInput.KEY_DOWN));
        inputManager.addMapping("SSAO", new KeyTrigger(KeyInput.KEY_O));
        inputManager.addMapping("PSSM", new KeyTrigger(KeyInput.KEY_P));
        inputManager.addMapping("MSAA", new KeyTrigger(KeyInput.KEY_K));
        inputManager.addMapping("FXAA", new KeyTrigger(KeyInput.KEY_L));

        inputManager.addListener(analogListener, new String[]{"Left", "Right", "Up", "Down"});
        inputManager.addListener(actionListener, new String[]{"SSAO", "PSSM", "MSAA", "FXAA"});
    }

    private AnalogListener analogListener = new AnalogListener() {
        public void onAnalog(String name, float value, float tpf) {
            if (name.equals("Left")) speedY -= 1f * tpf;
            if (name.equals("Right")) speedY += 1f * tpf;
            if (name.equals("Up")) speedX += 1f * tpf;
            if (name.equals("Down")) speedX -= 1f * tpf;
        }
    };

    private ActionListener actionListener = new ActionListener() {
        public void onAction(String name, boolean keyPressed, float tpf) {
            // shadows
            if (name.equals("PSSM") && keyPressed) {
                if (viewPort.getProcessors().contains(pssmRenderer)) viewPort.removeProcessor(pssmRenderer);
                else viewPort.addProcessor(pssmRenderer);
            }
            // hardware MSAA
            if (name.equals("MSAA") && keyPressed) {
                int samples = settings.getSamples();
                if (samples == 0) settings.setSamples(2);
                else if (samples < 16) settings.setSamples(samples * 2);
                else settings.setSamples(0);
                app.setSettings(settings);
                app.restart();
            }
            // ssao filter
            if (name.equals("SSAO") && keyPressed) {
                viewPort.removeProcessor(fpp);
                if (useSSAO) fpp.removeFilter(ssaoFilter);
                else fpp.addFilter(ssaoFilter);
                viewPort.addProcessor(fpp);
                useSSAO = !useSSAO;
            }
            //fxaa
            if (name.equals("FXAA") && keyPressed) {
                viewPort.removeProcessor(fpp);
                if (useFXAA) fpp.removeFilter(fxaaFilter);
                else fpp.addFilter(fxaaFilter);
                viewPort.addProcessor(fpp);
                useFXAA = !useFXAA;
            }

            updatePostInfo();
        }
    };

    private void setupFloor() {
        Material mat = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md");
        mat.setBoolean("UseMaterialColors", true);
        mat.setColor("Ambient", ColorRGBA.Gray);
        mat.setColor("Diffuse", ColorRGBA.Gray);
        mat.setColor("Specular", ColorRGBA.Gray);
        mat.setFloat("Shininess", 2);

        Geometry box = new Geometry("Floor", new Box(Vector3f.ZERO, 5f, 0.1f, 5f));
        box.setMaterial(mat);
        box.setShadowMode(ShadowMode.Receive);
        rootNode.attachChild(box);
    }

    private void setupBox() {
        Material mat = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md");
        mat.setBoolean("UseMaterialColors", true);
        mat.setColor("Ambient", ColorRGBA.White);
        mat.setColor("Diffuse", ColorRGBA.White);
        mat.setColor("Specular", ColorRGBA.White);
        mat.setFloat("Shininess", 12);

        Geometry box = new Geometry("Box", new Box(Vector3f.ZERO, 1, 1, 1));
        box.setMaterial(mat);
        box.setShadowMode(ShadowMode.CastAndReceive);

        Node pivot = new Node("pivot");
        pivot.move(0f, 2f, 0f);
        pivot.attachChild(box);

        rootNode.attachChild(pivot);
    }

    private void setupLights() {
        DirectionalLight dl = new DirectionalLight();
        dl.setDirection(lightDirection.normalizeLocal());
        dl.setColor(ColorRGBA.White);
        rootNode.addLight(dl);

        AmbientLight al = new AmbientLight();
        al.setColor(ColorRGBA.White.mult(0.2f));
        rootNode.addLight(al);
    }

    private void setupPost() {
        // set up fpp
        fpp = new FilterPostProcessor(assetManager);
        fpp.setNumSamples(1);

        // post proc filters
        ssaoFilter = new SSAOFilter(12.940201f, 43.928635f, 0.32999992f, 0.6059958f);
        fxaaFilter = new FXAAFilter();

        // shadows
        pssmRenderer = new PssmShadowRenderer(assetManager, 1024, 3);
        pssmRenderer.setDirection(lightDirection.normalizeLocal());
        rootNode.setShadowMode(ShadowMode.Off);
    }

    private void updatePostInfo() {
        boolean hasPSSM = (viewPort.getProcessors().contains(pssmRenderer));
        int samples = settings.getSamples();

        postInfo = "";
        if (hasPSSM) postInfo += "PSSM, ";
        if (useSSAO) postInfo += "SSAO, ";
        if (useFXAA) postInfo += "FXAA, ";
        postInfo += samples + "xAA";

        postText.setText(postInfo);
        postText.setLocalTranslation(settings.getWidth() - postText.getLineWidth() - 10,
                settings.getHeight() - postText.getLineHeight() + 5, 0);
    }

    @Override
    public void simpleUpdate(float tpf) {
        rootNode.getChild("pivot").rotate(speedX*tpf, speedY*tpf, 0f);
    }
}