package space.m0e.quga.oop.lab56maven;

import javafx.animation.AnimationTimer;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.SnapshotParameters;
import javafx.scene.control.Alert;
import javafx.scene.control.Label;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.scene.transform.Scale;
import javafx.stage.FileChooser;
import javafx.stage.Stage;
import javafx.util.Duration;
import space.m0e.quga.oop.lab56maven.dialogs.CountDialog;
import  space.m0e.quga.oop.lab56maven.dialogs.InsertDialog;
import space.m0e.quga.oop.lab56maven.dialogs.SearchDialog;
import  space.m0e.quga.oop.lab56maven.entities.common.Ability;
import space.m0e.quga.oop.lab56maven.entities.common.MiniMap;
import space.m0e.quga.oop.lab56maven.entities.common.Utils;
import  space.m0e.quga.oop.lab56maven.entities.macro.Fortress;
import  space.m0e.quga.oop.lab56maven.entities.macro.ThroneRoom;
import  space.m0e.quga.oop.lab56maven.entities.macro.Workstation;
import  space.m0e.quga.oop.lab56maven.entities.micro.Dwarf;
import  space.m0e.quga.oop.lab56maven.entities.micro.Immigrant;
import space.m0e.quga.oop.lab56maven.entities.micro.Nobel;
import space.m0e.quga.oop.lab56maven.handlers.DwarfHandler;
import space.m0e.quga.oop.lab56maven.handlers.ImmigrantHandler;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

public class Main extends Application {
    public static Group root = new Group();
    public static Group group = new Group();
    public static ArrayList<Immigrant> immigrants = new ArrayList<>();
    public static ArrayList<Fortress> fortresses = new ArrayList<>();
    public static Label status = new Label();

    public static MiniMap miniMap;

    public static final double width = 3555;
    public static final double height = 2000;

    public static ImageView imgviewmap;
    public static Rectangle rectMinimap;

    @Override
    public void start(Stage stage) throws IOException, InterruptedException {
        Rectangle rect = new Rectangle(width, height, Color.WHITE);

        FileChooser fileChooser = new FileChooser();
        fileChooser.setInitialFileName("serial.csv");

        root.getChildren().add(rect);
        Fortress fortress = new Fortress("Eartha", 150, 150,
                new ArrayList<>(List.of(
                        new Workstation("Torgrus", Ability.MASONIST),
                        new Workstation("Abbacus", Ability.WOODCUTTER)
                )),
                new ArrayList<>(List.of(
                        new ThroneRoom("Halzorga"))
                ));

        Fortress fortressTrade = new Fortress("Aboba", 1000, 150,
                new ArrayList<>(List.of(
                        new Workstation("Torgrass", Ability.WOODCUTTER)
                )),
                new ArrayList<>(List.of(
                )));
        fortresses.add(fortressTrade);
        fortresses.add(fortress);
        fortressTrade.setWoodCount(999);

//        immigrants.add(new Immigrant("Melbil", "Lancerpaddle", 50, 100,100, Ability.WOODCUTTER));
//        immigrants.add(new Immigrant("Atír", "Razorpaddle", 50, 0,0, Ability.WOODCUTTER));
//        immigrants.add(new Immigrant("Onget", "Sabreletter", 52, 200,150, Ability.WOODCUTTER));
        immigrants.add(new Immigrant("Limul", "Rockrack", 52, 700,150, Ability.WOODCUTTER));

        root.getChildren().add(status);
        group.getChildren().add(root);
        Scene scene = new Scene(group, width/4, height/4);

        scene.setOnKeyPressed(event -> {
            switch (event.getCode()) {
                case LEFT -> moveImmigrants(-10, 0);
                case RIGHT -> moveImmigrants(10, 0);
                case UP -> moveImmigrants(0, -10);
                case DOWN -> moveImmigrants(0, 10);
                case INSERT -> {
                    try {
                        InsertDialog.display();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

                case DELETE -> {
                    Iterator<Immigrant> iterator = immigrants.iterator();
                    while (iterator.hasNext()) {
                        Immigrant immigrant = iterator.next();
                        if (immigrant.isActive()) {
                            iterator.remove();
                            root.getChildren().remove(immigrant.getGroup());
                        }
                    }
                    processImmigrants();
                }

                case ESCAPE -> {
                    immigrants.forEach(immigrant -> {
                        immigrant.setActive(false);
                    });
                }

                case END -> {
                    immigrants.stream().filter(immigrant -> immigrant.isActive() && immigrant instanceof Dwarf).forEach(immigrant -> {
                        Dwarf dwarf = (Dwarf) immigrant;
                        if (dwarf.getFortress() != null)
                            Platform.runLater(() -> {
                                dwarf.setX(dwarf.getFortress().getX()-50);
                                dwarf.setY(dwarf.getFortress().getY()-50);
                                dwarf.setActive(false);
                                dwarf.free();
                            });
                    });
                }

                case F -> {
                    try {
                        SearchDialog.display();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

                case C -> {
                    try {
                        CountDialog.display();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

                case TAB -> {
                    Alert alert = new Alert(Alert.AlertType.INFORMATION);
                    alert.setTitle("Object list");
                    alert.setHeaderText("Object list");
                    alert.setContentText(immigrants.stream().map(Immigrant::toString).collect(Collectors.joining("\n")));
                    alert.showAndWait();
                }

                case W -> {
                    if (root.getLayoutY() + 20 <= 0)
                        root.setLayoutY(root.getLayoutY()+20);
                }

                case S -> {
                    if (root.getLayoutY() - 20 - stage.getHeight() >= -height)
                        root.setLayoutY(root.getLayoutY()-20);
                }

                case A -> {
                    if (root.getLayoutX() + 20 <= 0)
                        root.setLayoutX(root.getLayoutX()+20);
                }

                case D -> {
                    if (root.getLayoutX() - 20 - stage.getWidth() >= -width)
                        root.setLayoutX(root.getLayoutX()-20);
                }

                case F5 -> {
                    File file = fileChooser.showSaveDialog(stage);
                    String finalSerializeData = ""; // "class,name,age,hp,max_hp,items,x,y\n";
                    finalSerializeData += immigrants.stream().map(Immigrant::serialize).collect(Collectors.joining("\n"));
                    finalSerializeData += "\n" + fortresses.stream().map(Fortress::serialize).collect(Collectors.joining("\n"));
                    System.out.println(finalSerializeData);
                    try {
                        BufferedWriter writer = new BufferedWriter(new FileWriter(file));
                        writer.write(finalSerializeData);
                        writer.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

                case F6 -> {
                    File file = fileChooser.showOpenDialog(stage);
                    try {
                        immigrants.forEach(immigrant -> {
                            if (Main.root.getChildren().contains(immigrant.getGroup())) {
                                Main.root.getChildren().remove(immigrant.getGroup());
                            } else {
                                fortresses.forEach(fortress1 -> {
                                    fortress1.removeFromContainer((Dwarf) immigrant);
                                    fortress1.remove((Dwarf) immigrant);
                                });
                            }
                            immigrant.getTimeline().stop();
                        });
                        immigrants.clear();
                        StringBuilder finalDeserializeData = new StringBuilder();
                        BufferedReader reader = new BufferedReader(new FileReader(file));
                        String line;
                        while ((line = reader.readLine()) != null) {
                            finalDeserializeData.append(line).append("\n");
                        }
                        Arrays.stream(finalDeserializeData.toString().split("\n")).forEach(data -> {
                            String[] params = data.split(",");
                            switch (params[0]) {
                                case "Immigrant" -> {
                                    Immigrant immigrant = new Immigrant(data);
                                    immigrant.getTimeline().play();
                                    immigrants.add(immigrant);
                                }
                                case "Dwarf" -> {
                                    Dwarf dwarf = new Dwarf(data);
                                    dwarf.getTimeline().play();
                                    immigrants.add(dwarf);
                                }
                                case "Nobel" -> {
                                    Dwarf nobel = new Nobel(data);
                                    nobel.getTimeline().play();
                                    immigrants.add(nobel);
                                }
                            }
                        });
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        root.setOnMouseClicked(event -> {
            switch (event.getButton()) {
                case SECONDARY -> {
                    try {
                        Utils.findImmigrants("Dwarves outside MacroObjects:", immigrant -> fortresses.stream().noneMatch(fortress1 -> fortress1.getDwarves().contains(immigrant)));
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        stage.setTitle("Hello!");
        stage.setScene(scene);
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleWithFixedDelay(() -> immigrants.forEach(immigrant -> {
            immigrant.getTimeline().play();
        }), 1, 1, TimeUnit.SECONDS);

//        isMiniMapVisible = !isMiniMapVisible;
//        if (isMiniMapVisible){
//
//            mainGroup.getChildren().add(miniMap);
//            mainGroup.getChildren().add(miniMap.rect);
//            UpdateTimer.play();
//        }
//        else{
//            mainGroup.getChildren().remove(miniMap);
//            mainGroup.getChildren().remove(miniMap.rect);
//            UpdateTimer.stop();
//        }
        miniMap = new MiniMap(400, 225, stage.getWidth()/10, stage.getHeight()/10,  root);
        mapTimer = new Timeline(new KeyFrame(Duration.seconds(1), new EventHandler<ActionEvent>()
        {
            @Override
            public void handle(ActionEvent event)
            {
                Platform.runLater(() -> {
                    miniMap.updateMap();
                    miniMap.setHeight(height/10);
                    miniMap.setWidth(width/10);
                    miniMap.rect.setHeight(stage.getHeight()/10);
                    miniMap.rect.setWidth(stage.getWidth()/10);
                });

                miniMap.rect.setX(-root.getLayoutX() / 10);
                miniMap.rect.setY(-root.getLayoutY() / 10);
            }
        }));
        mapTimer.setCycleCount(Timeline.INDEFINITE);
        group.getChildren().add(miniMap);
        group.getChildren().add(miniMap.rect);
        mapTimer.play();

        stage.show();
    }

    public static Timeline mapTimer;

    private void moveImmigrants(double dx, double dy) {
        immigrants.forEach(immigrant -> {
            if (immigrant.isActive()) {
                Platform.runLater(() -> {
                    immigrant.setX(immigrant.getX() + dx);
                    immigrant.setY(immigrant.getY() + dy);
                });
            }
        });
    }

    public static void processImmigrants() {
        status.setText("Active:");
        immigrants.forEach(immigrant -> {
            if (immigrant.isActive()) {
                status.setText(status.getText() + " " + immigrant.getFullName());
            }
        });
    }

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