package fr.helliotk.redisinterfaceserver.networking;

import lombok.Getter;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.*;

public class ServerManager {

    @Getter
    private int port;

    private ServerManager instance;
    @Getter
    private ServerSocket serverSocket;

    private boolean isServerOn = false;
    private Thread listenConnectionsThread;

    private ArrayList<ConnectedClient> connectedClients = new ArrayList<>();
    private ArrayList<Thread> authThreads = new ArrayList<>();
    private HashMap<String, String> users = new HashMap<>();
    private int clientsNumber;

    public ServerManager(int port) {
        this.port = port;

        try {
            serverSocket = new ServerSocket(port);
            isServerOn = true;
            this.instance = this;
            clientsNumber = 0;

            users.put("Helliot", "bite");
            users.put("Qilat", "queue");

            enableListenConnections(); //async

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void enableListenConnections(){
        listenConnectionsThread = new Thread(new Runnable() {
            @Override
            public void run() {
                listenConnections();
            }
        }, "Server-Listen-Connections");

        listenConnectionsThread.start();
    }

    private void disableListenConnections(){
        if(listenConnectionsThread != null && !listenConnectionsThread.isInterrupted()){
            listenConnectionsThread.interrupt();
        }
    }

    private void listenConnections(){
        try {
            Socket socket = serverSocket.accept();
            if(socket != null){
                handleAuth(socket);

                if(isServerOn)
                    listenConnections();
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    private void handleAuth(Socket socket){
        try{
            InputStream inputStream = socket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));

            String authString = reader.readLine();
            if(authString != null && authString.length() > 0){
                String[] authArray = authString.split(":");
                if(authArray.length == 3 && authArray[0].equals("AUTH_PACKET_INPUT")){
                    String username = authArray[1];
                    String password = authArray[2];

                    if(users.containsKey(username)){
                        if(password.equals(users.get(username))){
                            if(getClient(username) == null){
                                acceptClient(socket, username);
                            }else{
                                denyClient(socket, "Already connected");
                            }
                        }else{
                            denyClient(socket, "Wrong password");
                        }
                    }else{
                        denyClient(socket, "Username not registered");
                    }
                }else{
                    denyClient(socket, "Invalid auth string");
                }
            }else{
                denyClient(socket, "Invalid auth string");
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    private void acceptClient(Socket socket, String username){
        UUID uuid = UUID.randomUUID();
        ConnectedClient client = new ConnectedClient(uuid, socket, instance, username);
        connectedClients.add(client);
        client.enableListening();
        System.out.println("Client " + username + " connected ! UUID: " + uuid);
        sendMessage("AUTH_PACKET_OUTPUT:true", client);
        broadcast("Client " + username + " connected !");
    }

    private void denyClient(Socket socket, String message){
        try{
            OutputStream outputStream = socket.getOutputStream();
            PrintStream writer = new PrintStream(outputStream, true);
            writer.println("AUTH_PACKET_OUTPUT:false:" + message);

            socket.close();
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    public void broadcast(String message){
        ArrayList<ConnectedClient> clonedConnectedClients = clonedConnectedClients();
        for (ConnectedClient client : clonedConnectedClients) {
            sendMessage(message, client);
        }
    }

    public void readMessage(String message, ConnectedClient author) {
        String formatedMessage = "Client " + author.getUsername() + " sent: " + message;
        System.out.println(formatedMessage);
        ArrayList<ConnectedClient> clonedConnectedClients = clonedConnectedClients();
        clonedConnectedClients.remove(author);
        for (ConnectedClient client : clonedConnectedClients) {
            sendMessage(formatedMessage, client);
        }
        /*
        if (message.equals("cutServer"))
            closeServer();
            */

    }

    public void sendMessage(String message, ConnectedClient target) {
        try {
            OutputStream outputStream = target.getSocket().getOutputStream();
            PrintStream writer = new PrintStream(outputStream, true);

            writer.println(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void disconnectClient(ConnectedClient client){
        try {
            client.setConnected(false);
            client.disableListening();

            if(!client.getSocket().isClosed()) {
                client.getSocket().close();
            }
            System.out.println("Client " + client.getUsername() + " disconnected !");
            broadcast("Client " + client.getUsername() + " disconnected !");
            connectedClients.remove(client);
            clientsNumber--;
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    private void closeServer(){
        System.out.println("Closing server...");

        disableListenConnections();

        for (ConnectedClient connectedClient : connectedClients) {
            disconnectClient(connectedClient);
        }

        isServerOn = false;

        try {
            serverSocket.close();
        }catch (IOException e){
            e.printStackTrace();
        }

        System.out.println("Server closed");
    }

    @SuppressWarnings("unchecked")
    private ArrayList<ConnectedClient> clonedConnectedClients(){
        return ((ArrayList<ConnectedClient>) connectedClients.clone());
    }

    public ConnectedClient getClient(String username){
        for (ConnectedClient client : clonedConnectedClients()) {
            if(client.getUsername().equalsIgnoreCase(username))
                return client;
        }

        return null;
    }

    public ConnectedClient getClient(UUID uuid){
        for (ConnectedClient client : clonedConnectedClients()) {
            if(client.getUuid().equals(uuid))
                return client;
        }

        return null;
    }