package com.mavlushechka.notaryqueue.controller;

import com.mavlushechka.notaryqueue.util.Socket;
import com.mavlushechka.notaryqueue.model.Client;
import com.mavlushechka.notaryqueue.model.Status;
import javafx.application.Platform;
import javafx.collections.ObservableList;
import javafx.fxml.FXML;
import javafx.scene.control.*;

import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class HelperController {


    public static HelperController instance;
    public boolean isMonitorScene;
    @FXML
    private ListView<Client> waitingClients = new ListView<>();
    @FXML
    private ListView<Client> processingClients = new ListView<>();
    @FXML
    private ListView<Client> readyClients = new ListView<>();
    private final ArrayList<Client> removedClients = new ArrayList<>();


    public HelperController() {
        instance = this;
    }

    public void setContextMenuToClientListViews() {
        MenuItem addClientOnProcessingClientsListView = new MenuItem("Qoshish");
        addClientOnProcessingClientsListView.setOnAction(event -> showAddClientDialogs());

        MenuItem waitClientOnProcessingClients = new MenuItem("Kutilmoqda");
        waitClientOnProcessingClients.setOnAction(event -> setSelectedClientStatus(processingClients, Status.WAITING));
        MenuItem waitClientOnReadyClients = new MenuItem("Kutilmoqda");
        waitClientOnReadyClients.setOnAction(event -> setSelectedClientStatus(readyClients, Status.WAITING));

        MenuItem processClientOnWaitingClients = new MenuItem("Bajarilmoqda");
        processClientOnWaitingClients.setOnAction(event -> setSelectedClientStatus(waitingClients, Status.PROCESSING));
        MenuItem processClientOnReadyClients = new MenuItem("Bajarilmoqda");
        processClientOnReadyClients.setOnAction(event -> setSelectedClientStatus(readyClients, Status.PROCESSING));

        MenuItem readyClientOnWaitingClients = new MenuItem("Tayyor");
        readyClientOnWaitingClients.setOnAction(event -> setSelectedClientStatus(waitingClients, Status.READY));
        MenuItem readyClientOnProcessingClients = new MenuItem("Tayyor");
        readyClientOnProcessingClients.setOnAction(event -> setSelectedClientStatus(processingClients, Status.READY));

        MenuItem removeClientOnWaitingClients = new MenuItem("O'chirish");
        removeClientOnWaitingClients.setOnAction(event -> showRemoveSelectedClientDialog(waitingClients));
        MenuItem removeClientOnProcessingClients = new MenuItem("O'chirish");
        removeClientOnProcessingClients.setOnAction(event -> showRemoveSelectedClientDialog(processingClients));
        MenuItem removeClientOnReadyClients = new MenuItem("O'chirish");
        removeClientOnReadyClients.setOnAction(event -> showRemoveSelectedClientDialog(readyClients));

        waitingClients.setContextMenu(new ContextMenu(processClientOnWaitingClients, readyClientOnWaitingClients, removeClientOnWaitingClients));
        processingClients.setContextMenu(new ContextMenu(addClientOnProcessingClientsListView, waitClientOnProcessingClients, readyClientOnProcessingClients, removeClientOnProcessingClients));
        readyClients.setContextMenu(new ContextMenu(waitClientOnReadyClients, processClientOnReadyClients, removeClientOnReadyClients));
    }

    public void loadClientsToListViews() {
//        try (ObjectInputStream objectInputStreamOfWaitingClients = new ObjectInputStream(new FileInputStream("target/serialization/waitingClients"))) {
//            ((ArrayList<Client>) objectInputStreamOfWaitingClients.readObject()).forEach(this::addClient);
//            Platform.runLater(() -> System.out.println("Waiting clients are loaded : " + waitingClients.getItems()));
//        } catch (IOException | ClassNotFoundException ignored) {
//            System.out.println("Waiting clients are not loaded.");
//        }
//        try (ObjectInputStream objectInputStreamOfProcessingClients = new ObjectInputStream(new FileInputStream("target/serialization/processingClients"))) {
//            ((ArrayList<Client>) objectInputStreamOfProcessingClients.readObject()).forEach(this::addClient);
//            Platform.runLater(() -> System.out.println("Processing clients are loaded : " + processingClients.getItems()));
//        } catch (IOException | ClassNotFoundException ignored) {
//            System.out.println("Processing clients are not loaded.");
//        }
//        try (ObjectInputStream objectInputStreamOfReadyClients = new ObjectInputStream(new FileInputStream("target/serialization/readyClients"))) {
//            ((ArrayList<Client>) objectInputStreamOfReadyClients.readObject()).forEach(this::addClient);
//            Platform.runLater(() -> System.out.println("Ready clients are loaded : " + readyClients.getItems()));
//        } catch (IOException | ClassNotFoundException ignored) {
//            System.out.println("Ready clients are not loaded.");
//        }
    }

    public void receiveUpdates() {
        new Thread(() -> {
            while (true) {
                removeClient(Socket.receiveDeletedClient());
            }
        }).start();
        new Thread(() -> {
            while (true) {
                addClient(Socket.receiveNewClient());
            }
        }).start();
    }

    public void addClient(Client client) {
        ObservableList<Client> observableList = null;
        switch (client.getStatus()) {
            case WAITING -> observableList = waitingClients.getItems();
            case PROCESSING -> observableList = processingClients.getItems();
            case READY -> observableList = readyClients.getItems();
        }

        if (isMonitorScene) {
            client.setClientDocumentTypeVisible(false);
            client.setLocalTimeVisible(false);
        }

        ObservableList<Client> finalObservableList = observableList;
        Platform.runLater(() -> {
            finalObservableList.add(client);
            System.out.println(client + " is added to " + client.getStatus().toString().toLowerCase() + " list.");
        });
    }

    public void removeClient(Client client) {
        ObservableList<Client> observableList = null;
        switch (client.getStatus()) {
            case WAITING -> observableList = waitingClients.getItems();
            case PROCESSING -> observableList = processingClients.getItems();
            case READY -> observableList = readyClients.getItems();
        }

        if (isMonitorScene) {
            client.setClientDocumentTypeVisible(false);
            client.setLocalTimeVisible(false);
        }

        ObservableList<Client> finalObservableList = observableList;
        Platform.runLater(() -> {
            boolean isRemoved = finalObservableList.remove(client);
            System.out.println(client + " is" + (isRemoved ? "" : " not") + " removed from " + client.getStatus().toString().toLowerCase() + " list.");
            if (isRemoved) {
                removedClients.add(client);
            }
        });
    }

    public void showAddClientDialogs() {
        TextInputDialog textInputDialog = new TextInputDialog();
        textInputDialog.setHeaderText("Mijozni ismi");
        Optional<String> clientName = textInputDialog.showAndWait();

        List<String> documents = List.of("Avto oldi-sotdi (hadya)", "Avto ishonchnoma", "Uy oldi-sotdi (hadya)", "Ipoteka, garov", "Ijara", "Meros vasiyatnoma", "Boshka ishonchnoma", "Boshka turdagi xarakatlar");
        ChoiceDialog<String> choiceDialog = new ChoiceDialog<>(documents.get(0), documents);
        choiceDialog.setHeaderText("Document");

        Optional<String> clientDocument = choiceDialog.showAndWait();
        Client client = new Client(String.format("%02d", getNumberOfClients() + 1), clientName.orElse("Error"), Status.PROCESSING, clientDocument.orElse("Error"), true, LocalTime.now(), true);
        Socket.sendNewClient(client);
    }

    public void showRemoveSelectedClientDialog(ListView<Client> clientsListView) {
        Client client = clientsListView.getSelectionModel().getSelectedItem();
        if (client == null) {
            throw new IllegalStateException("Client is not selected");
        }

        Dialog<ButtonType> dialog = new Dialog<>();
        dialog.setHeaderText(client.name + "'ni oʻchirib tashlamoqchimisiz?");
        dialog.getDialogPane().getButtonTypes().add(new ButtonType("Yo'q", ButtonBar.ButtonData.NO));
        dialog.getDialogPane().getButtonTypes().add(new ButtonType("Ha", ButtonBar.ButtonData.YES));

        Optional<ButtonType> answer = dialog.showAndWait();
        if ("Y".equals(answer.orElse(new ButtonType("Error")).getButtonData().getTypeCode())) {
            Socket.sendDeletedClient(client);
        }
    }

    public int getNumberOfClients() {
        return waitingClients.getItems().size() + processingClients.getItems().size() + readyClients.getItems().size() + removedClients.size();
    }

    private void setSelectedClientStatus(ListView<Client> clientsListView, Status status) {
        Client client = clientsListView.getSelectionModel().getSelectedItem();
        if (client == null) {
            throw new IllegalStateException("Client is not selected");
        }
        Socket.sendDeletedClient(client);

        Client newClient = new Client(client);
        newClient.setStatus(status);
        Socket.sendNewClient(newClient);
    }

}