package org.javafx3d;

import com.interactivemesh.jfx.importer.obj.ObjModelImporter;
import jaco.mp3.player.MP3Player;
import javafx.animation.Interpolator;
import javafx.animation.RotateTransition;
import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Node;
import javafx.scene.PerspectiveCamera;
import javafx.scene.Scene;
import javafx.scene.image.Image;
import javafx.scene.input.KeyEvent;
import javafx.scene.paint.PhongMaterial;
import javafx.scene.shape.MeshView;
import javafx.scene.transform.Rotate;
import javafx.stage.Stage;
import javafx.util.Duration;

import java.io.File;
import java.util.HashMap;
import java.util.Map;


public class GramophoneApp extends Application {

    private Group model = loadModel();
    private PerspectiveCamera camera;
    private Stage stage;
    private MP3Player player;
    private RotateTransition rt;
    private Map<Node, RotateTransition> elementsAbleToRotate = new HashMap<>();

    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage stage) throws Exception {
        this.stage = stage;
        stage.setScene(createScene());
        stage.show();
    }

    private Scene createScene() {
        Group root = new Group(model);
        Scene scene = new Scene(root, 1500, 1000, true);
        setCamera();
        scene.setCamera(camera);
        handleKeyPressing();
        handleKeyReleasing();
        loadTrack();
        setMaterial();
        return scene;
    }

    private void setCamera() {
        camera = new PerspectiveCamera(true);
        camera.translateXProperty().set(0.2);
        camera.translateZProperty().set(-7);
        model.getTransforms().add(new Rotate(50, Rotate.X_AXIS));
    }


    private void handleKeyPressing() {
        stage.addEventHandler(
                KeyEvent.KEY_PRESSED, event -> {
                    switch (event.getCode()) {
                        case UP:
                            camera.translateYProperty().set(camera.getTranslateY() - 0.1);
                            break;
                        case DOWN:
                            camera.translateYProperty().set(camera.getTranslateY() + 0.1);
                            break;
                        case RIGHT:
                            camera.translateXProperty().set(camera.getTranslateX() + 0.1);
                            break;
                        case LEFT:
                            camera.translateXProperty().set(camera.getTranslateX() - 0.1);
                            System.out.println(camera.getTranslateX());
                            break;
                        case P:
                            camera.translateZProperty().set(camera.getTranslateZ() + 0.1);
                            break;
                        case O:
                            camera.translateZProperty().set(camera.getTranslateZ() - 0.1);
                            break;
                        case ENTER:
                            animate(true);
                            System.out.println("play");
                            if (player != null) {
                                if (player.isStopped() || player.isPaused()) {
                                    player.play();
                                }
                            }
                            break;
                    }
                });
    }

    private void loadTrack() {

        player = new MP3Player();
        File file = new File("Living_on_a_prayer.mp3");

        player.addToPlayList(file);
    }

    private void handleKeyReleasing() {
        stage.addEventHandler(KeyEvent.KEY_RELEASED, event -> {
            switch (event.getCode()) {
                case ENTER:
                    animate(false);
                    player.pause();
                    break;
            }
            if (player != null) {
                player.pause();
            }
        });
    }

    private Group loadModel() {
        Group modelRoot = new Group();
        ObjModelImporter importer = new ObjModelImporter();
        importer.read("gramofon.obj");
        for (MeshView view : importer.getImport()) {
            modelRoot.getChildren().add(view);
        }
        return modelRoot;
    }

    private void animate(boolean rotate) {

        model.getChildren()
                .stream()
                .filter(view ->
                        view.getId().toLowerCase().contains("plyta")
                )
                .forEach(view -> {
                            elementsAbleToRotate.entrySet().stream().filter(element -> element.getKey().equals(view)).findAny().ifPresent((element -> {
                                rt = element.getValue();
                                if (!rotate) {
                                    rt.stop();
                                } else
                                    rt.play();

                            }));
                            if (elementsAbleToRotate.entrySet().stream().noneMatch(element -> element.getKey().equals(view))) {
                                rt = new RotateTransition(Duration.seconds(1), view);
                                rt.setCycleCount(Integer.MAX_VALUE);
                                rt.setAxis(Rotate.Y_AXIS);
                                rt.setByAngle(360);
                                rt.setInterpolator(Interpolator.LINEAR);
                                elementsAbleToRotate.put(view, rt);
                                if (!rotate) {
                                    rt.stop();
                                } else
                                    rt.play();
                            }
                        }

                );
    }


    private void setMaterial() {
        PhongMaterial material = new PhongMaterial();
        model.getChildren().forEach(element -> {
            if (element.getId().toLowerCase().equals("plane")) {
                material.setDiffuseMap(new Image("wood.jpg"));
                ((MeshView) element).setMaterial(material);
            }
        });
    }


}