package visualiser.Controllers;

import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.fxml.FXML;
import javafx.scene.control.Button;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.control.TextField;
import javafx.scene.layout.AnchorPane;
import mock.app.Event;
import shared.exceptions.InvalidBoatDataException;
import shared.exceptions.InvalidRaceDataException;
import shared.exceptions.InvalidRegattaDataException;
import shared.exceptions.XMLReaderException;
import visualiser.model.RaceConnection;

import java.io.IOException;
import java.net.Socket;
import java.net.URL;
import java.net.UnknownHostException;
import java.util.ResourceBundle;

/**
 * Controls the connection that the VIsualiser can connect to.
 */
public class ConnectionController extends Controller {
    @FXML
    private AnchorPane connectionWrapper;
    @FXML
    private TableView<RaceConnection> connectionTable;
    @FXML
    private TableColumn<RaceConnection, String> hostnameColumn;
    @FXML
    private TableColumn<RaceConnection, String> statusColumn;
    @FXML
    private Button connectButton;

    @FXML
    private TextField urlField;
    @FXML
    private TextField portField;

    private ObservableList<RaceConnection> connections;


    /**
     * Represents whether the client is currently hosting a game already - this is to ensure they don't launch multiple servers.
     */
    private boolean currentlyHostingGame = false;


    @Override
    public void initialize(URL location, ResourceBundle resources) {
        // TODO - replace with config file
        connections = FXCollections.observableArrayList();

        connectionTable.setItems(connections);
        hostnameColumn.setCellValueFactory(cellData -> cellData.getValue().hostnameProperty());
        statusColumn.setCellValueFactory(cellData -> cellData.getValue().statusProperty());

        connectionTable.getSelectionModel().selectedItemProperty().addListener((obs, prev, curr) -> {
            if (curr != null && curr.check()) connectButton.setDisable(false);
            else connectButton.setDisable(true);
        });
        connectButton.setDisable(true);
    }

    /**
     * Sets current status of all connections.
     */
    public void checkConnections() {
        for(RaceConnection connection: connections) {
            connection.check();
        }
    }

    public AnchorPane startWrapper(){
        return connectionWrapper;
    }

    /**
     * Connects to host currently selected in table. Button enabled only if host is ready.
     */
    public void connectSocket() {
        try{
            RaceConnection connection = connectionTable.getSelectionModel().getSelectedItem();
            Socket socket = new Socket(connection.getHostname(), connection.getPort());
            socket.setKeepAlive(true);
            connectionWrapper.setVisible(false);
            parent.enterLobby(socket);
        } catch (IOException e) { /* Never reached */ }
    }

    /**
     * adds a new connection
     */
    public void addConnection(){
        String hostName = urlField.getText();
        String portString = portField.getText();
        try{
            int port = Integer.parseInt(portString);
            connections.add(new RaceConnection(hostName, port));
        }catch(NumberFormatException e){
            System.err.println("Port number entered is not a number");
        }
    }

    /**
     * Sets up a new host
     */
    public void addLocal() {
        try {
            //We don't want to host more than one game.
            if (!currentlyHostingGame) {
                Event game = Event.getEvent();
                urlField.textProperty().set(game.getAddress());
                portField.textProperty().set(Integer.toString(game.getPort()));

                game.start();
                addConnection();

                currentlyHostingGame = true;
            }
        } catch (InvalidRaceDataException e) {
            e.printStackTrace();
        } catch (XMLReaderException e) {
            e.printStackTrace();
        } catch (InvalidBoatDataException e) {
            e.printStackTrace();
        } catch (InvalidRegattaDataException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}