package com.lumaserv.bgp;

import com.lumaserv.bgp.protocol.BGPPacket;
import com.lumaserv.bgp.protocol.message.BGPNotification;
import com.lumaserv.bgp.protocol.message.BGPOpen;
import lombok.Getter;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class BGPServer implements Runnable {

    final ServerSocket serverSocket;
    @Getter
    final List<BGPSessionConfiguration> sessionConfigurations = new ArrayList<>();
    final List<BGPSession> sessions = new ArrayList<>();

    public BGPServer() throws IOException {
        this(179);
    }

    public BGPServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    private static boolean checkEqual(byte[] a, byte[] b) {
        if(a == b)
            return true;
        if(a == null || b == null)
            return false;
        if(a.length != b.length)
            return false;
        for(int i=0; i<a.length; i++) {
            if(a[i] != b[i])
                return false;
        }
        return true;
    }

    public boolean hasCollided(BGPSession session, BGPOpen msg) {
        for (BGPSession otherSession : sessions) {
            BGPFsm fsm = otherSession.getFsm();
            BGPFsm.State state = fsm.getCurrentState();

            // May examine OPEN_SENT
            if (state == fsm.OPEN_SENT
                && otherSession.getConfiguration() == null)
                continue;

            // Cannot detect collision
            if (state == fsm.IDLE
                || state == fsm.CONNECT
                || state == fsm.ACTIVE)
                continue;

            // Detect collision
            if (session.getInetAddress() != otherSession.getLocalAddress()
                || session.getLocalAddress() != otherSession.getInetAddress())
                continue;

            // Collision!
            if (state == fsm.ESTABLISHED) {
                // Close new connection
                sessions.remove(session);
                return true;
            }

            byte[] remoteIdentifier;
            byte[] localIdentifier = session.getConfiguration()
                .getLocalIdentifier();

            if (state == fsm.OPEN_SENT) {
                remoteIdentifier = otherSession.getConfiguration()
                    .getRemoteIdentifier();
            } else { // state == BGPFsm.OPEN_CONFIRM
                remoteIdentifier = otherSession.getRemoteIdentifier();
            }

            boolean isLocalIdLess = false;

            // Compare integer stored in network byte order
            for (int i=0; i < 4; i++) {
                if (localIdentifier[i] < remoteIdentifier[i]) {
                    isLocalIdLess = true;
                    break;
                }
            }

            if (isLocalIdLess) {
                // Close existing connection
                BGPNotification notification = new BGPNotification()
                    .setMajorErrorCode(BGPNotification.Error.CEASE.getCode());
                try {
                    otherSession.sendNotification(notification);
                } catch(IOException ex) {
                }
                sessions.remove(otherSession);
                otherSession.dropConnection();
                otherSession.cleanup();
                // Accept new connection
                return false;
            } else {
                // Close new connection
                sessions.remove(session);
                return true;
            }
        }

        return false;
    }

    public void run() {
        while (true) {
            try {
                Socket socket = serverSocket.accept();
                System.out.println("Accept");

                BGPSessionConfiguration config = sessionConfigurations.stream()
                        .filter(c -> socket.getInetAddress().equals(c.getRemoteAddr()))
                        .findFirst()
                        .orElse(null);
                System.out.println("Config: " + config);
                if(config == null) {
                    System.out.println("Peer not found:" + socket.getInetAddress());
                    socket.close();
                    continue;
                }

                BGPSession session = new BGPSession(this, socket, config);
                sessions.add(session);
                session.getFsm().getCurrentState().automaticStartPassive();

                // System.out.println("tcpConnectionConfirmed in " + fsm.getCurrentState());
                // fsm.getCurrentState().tcpConnectionConfirmed();
            } catch (IOException ex) {
                if (serverSocket.isClosed())
                    break;
                ex.printStackTrace();
            }
        }
    }

    public boolean connect(BGPSessionConfiguration config, String host) throws IOException {
        return connect(config, host, 179);
    }

    public boolean connect(BGPSessionConfiguration config, String host, int port) throws IOException {
        for (BGPSession session : sessions) {
            if (session.getConfiguration().equals(config)) {
                // Already connected
                return false;
            }
        }

        try {
            BGPSession session = new BGPSession(this, config, host, port);
            sessions.add(session);
            session.getFsm().getCurrentState().automaticStart();
            return true;
        } catch (IOException ex) {
            ex.printStackTrace();
            throw(ex);
        }
    }

    public void shutdown() {
        for(BGPSession session : sessions) {
            session.automaticStop();
            session.cleanup();
        }
        sessions.clear();
        if (serverSocket != null) {
            try {
                serverSocket.close();
            } catch(IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}