package PyMc;

import org.bukkit.Bukkit;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import PyMc.Utils;


public class PyMc extends JavaPlugin {
    private ServerSocket serverSocket;
    private boolean running = true;

    @Override
    public void onEnable() {
        getLogger().info("Enabling PyMc...");
        startServer(12345);
    }

    @Override
    public void onDisable() {
        getLogger().info("Disabling PyMc...");
        stopServer();
    }

    public void startServer(int port) {
        new Thread(() -> {
            try {
                serverSocket = new ServerSocket(port);
                getLogger().info("Server is listening on port " + port);

                while (running) {
                    Socket socket = serverSocket.accept();
                    getLogger().info("New client connected");

                    new ClientHandler(socket).start();
                }
            } catch (IOException ex) {
                getLogger().severe("Server exception: " + ex.getMessage());
                ex.printStackTrace();
            }
        }).start();
    }

    public void stopServer() {
        running = false;
        try {
            if (serverSocket != null && !serverSocket.isClosed()) {
                serverSocket.close();
            }
        } catch (IOException ex) {
            getLogger().severe("Error closing server socket: " + ex.getMessage());
            ex.printStackTrace();
        }
    }

    class ClientHandler extends Thread {
        private Socket socket;

        public ClientHandler(Socket socket) {
            this.socket = socket;
        }

        public void run() {
            try (InputStream input = socket.getInputStream();
                 BufferedReader reader = new BufferedReader(new InputStreamReader(input));
                 OutputStream output = socket.getOutputStream();
                 PrintWriter writer = new PrintWriter(output, true)) {

                String text;

                do {
                    text = reader.readLine();
                    getLogger().info("Received from client: " + text);

                    String[] parts = text.split(" ", 2);
                    if (parts.length < 2) {
                        writer.println("Invalid command format: " + text);
                        continue;
                    }

                    String command = parts[0].toLowerCase();
                    String arguments = parts[1];

                    switch (command) {
                        case "say":
                            // format: say <player:<player>/all::players><text>
                            String[] sayArgs = arguments.split(" ", 2);
                            if (sayArgs.length != 2) {
                                writer.println("Invalid say command format: " + arguments);
                                break;
                            }

                            String target = sayArgs[0].toLowerCase();
                            String message = sayArgs[1];

                            switch (target) {
                                case "all::players":
                                    Utils.send(Bukkit.getConsoleSender(), message);
                                    break;
                                case "player":
                                    String[] playerArgs = message.split(" ", 2);
                                    if (playerArgs.length != 2 || !playerArgs[0].startsWith("player:")) {
                                        writer.println("Invalid player format in say command: " + message);
                                        break;
                                    }

                                    String playerName = playerArgs[0].substring("player:".length());
                                    String playerMessage = playerArgs[1];

                                    Player targetPlayer = Bukkit.getPlayerExact(playerName);
                                    if (targetPlayer != null) {
                                        Utils.send(targetPlayer, playerMessage);
                                    } else {
                                        writer.println("Player " + playerName + " is not online.");
                                    }
                                    break;
                                default:
                                    writer.println("Unknown target in say command: " + target);
                            }
                            break;
                        case "execute":
                            String[] executeArgs = arguments.split(" ", 2);
                            if (executeArgs.length != 2) {
                                writer.println("Invalid execute command format: " + arguments);
                                break;
                            }

                            String executor = executeArgs[0].toLowerCase();
                            String commandToExecute = executeArgs[1];

                            switch (executor) {
                                case "console":
                                    Utils.executeAsConsole(commandToExecute);
                                    break;
                                case "player":
                                    String[] playerArgs = commandToExecute.split(" ", 2);
                                    if (playerArgs.length != 2 || !playerArgs[0].startsWith("player:")) {
                                        writer.println("Invalid player format in execute command: " + commandToExecute);
                                        break;
                                    }

                                    String playerName = playerArgs[0].substring("player:".length());
                                    String playerCommand = playerArgs[1];

                                    Player targetPlayer = Bukkit.getPlayerExact(playerName);
                                    if (targetPlayer != null) {
                                        Utils.executeAsPlayer(targetPlayer, playerCommand);
                                    } else {
                                        writer.println("Player " + playerName + " is not online.");
                                    }
                                    break;
                                default:
                                    writer.println("Unknown executor in execute command: " + executor);
                            }
                            break;
                        case "log":
                            String latestChatMessage = Utils.getLatestChatMessage();
                            Utils.sendToClients(latestChatMessage);
                            break;
                        default:
                            writer.println("Unknown command: " + command);
                    }

                } while (!text.equals("bye"));

                socket.close();
                getLogger().info("Client disconnected");

            } catch (IOException ex) {
                getLogger().severe("Server exception: " + ex.getMessage());
                ex.printStackTrace();
            }
        }
    }
}