import java.io.InputStreamReader;
import java.sql.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Scanner;

public class Diagnostico {

    private final String DATAFILE = "data/disease_data.data";
    private Connection connection = null;

    private void showMenu() {

        int option = -1;
        do {
            System.out.println("Bienvenido a sistema de diagnóstico\n");
            System.out.println("Selecciona una opción:\n");
            System.out.println("\t1. Creación de base de datos y carga de datos.");
            System.out.println("\t2. Realizar diagnóstico.");
            System.out.println("\t3. Listar síntomas de una enfermedad.");
            System.out.println("\t4. Listar enfermedades y sus códigos asociados.");
            System.out.println("\t5. Listar síntomas existentes en la BD y su tipo semántico.");
            System.out.println("\t6. Mostrar estadísticas de la base de datos.");
            System.out.println("\t7. Salir.");
            try {
                option = readInt();
                switch (option) {
                    case 1:
                        crearBD();
                        break;
                    case 2:
                        realizarDiagnostico();
                        break;
                    case 3:
                        listarSintomasEnfermedad();
                        break;
                    case 4:
                        listarEnfermedadesYCodigosAsociados();
                        break;
                    case 5:
                        listarSintomasYTiposSemanticos();
                        break;
                    case 6:
                        mostrarEstadisticasBD();
                        break;
                    case 7:
                        exit();
                        break;
                }
            } catch (Exception e) {
                System.err.println("Opción introducida no válida!");
                e.printStackTrace();
            }
        } while (option != 7);
        exit();
    }

    private void exit() {
        try {
            connection.close();
            System.out.println("Saliendo... ¡hasta otra!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }

    /**
     * Método para establecer conexión con la base de datos.
     *
     * @throws Exception Puede lanzar excepción.
     */
    private void conectar() throws Exception {
        if (connection == null) {
            try {
                Class.forName("com.mysql.jdbc.Driver");
                connection = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/",
                        "bddx",
                        "bddx_pwd");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * Método para crear la base de datos, tablas e importar datos.
     *
     * @throws Exception Puede lanzar alguna excepción, en cuyo caso,
     *                   hace ROLLBACK y elimina las tablas y base de datos creadas.
     */
    private void crearBD() {

        /*
         * Se conecta con JDBC a través del método conectar(). Acto seguido,
         * seprocede a crear la base de datos y las tablas para dejar paso
         * a importación de datos posteriormente.
         */
        try {
            conectar();
            LinkedList<String> archivo = readData();
            ArrayList<String> sentenciasSQL = new ArrayList<>();
            sentenciasSQL.add("CREATE DATABASE diagnostico;");
            sentenciasSQL.add("USE diagnostico;");
            sentenciasSQL.add("CREATE TABLE disease (" +
                    "disease_id INT AUTO_INCREMENT, " +
                    "name VARCHAR(255), " +
                    "PRIMARY KEY (disease_id)" +
                    ");");
            sentenciasSQL.add("CREATE TABLE disease_has_code (" +
                    "disease_id INT, " +
                    "code VARCHAR(255), " +
                    "source_id INT, " +
                    "FOREIGN KEY (disease_id) REFERENCES disease(disease_id), " +
                    "FOREIGN KEY (code) REFERENCES code(code), " +
                    "FOREIGN KEY (source_id) REFERENCES source(source_id)" +
                    ");");
            sentenciasSQL.add("CREATE TABLE disease_symptom (" +
                    "disease_id INT, " +
                    "cui VARCHAR(25), " +
                    "FOREIGN KEY (disease_id) REFERENCES disease(disease_id), " +
                    "FOREIGN KEY (cui) REFERENCES symptom(cui)" +
                    ");");
            sentenciasSQL.add("CREATE TABLE code (" +
                    "code VARCHAR(255), " +
                    "source_id INT, " +
                    "PRIMARY KEY (code), " +
                    "FOREIGN KEY source_id REFERENCES source(source_id)" +
                    ");");
            sentenciasSQL.add("CREATE TABLE source (" +
                    "source_id INT AUTO_INCREMENT, " +
                    "name VARCHAR(255), " +
                    "PRIMARY KEY (source_id)" +
                    ");");
            sentenciasSQL.add("CREATE TABLE symptom (" +
                    "cui VARCHAR(25), " +
                    "name VARCHAR(255), " +
                    "st VARCHAR(45)" +
                    "PRIMARY KEY (cui)" +
                    ");");

            /*
             * Dado que las sentencias CREATE implican un COMMIT automático, comenzaremos la
             * transacción antes de las sentencias INSERT. Ahora se interpretan y segmentan los
             * datos de disease_data.data y se crean las sentencias de importación.
             */
            sentenciasSQL.add("START TRANSACTION;");
            for (String linea : archivo) {
                String[] d1 = linea.split("=");
                String[] e1 = d1[0].split(":");
                String nombreEnfermedad = e1[0];
                sentenciasSQL.add("INSERT INTO disease VALUES (" +
                        "" + nombreEnfermedad + "" +
                        ");");
                String[] datosEnfermedad = e1[1].split(";");
                for (String dato : datosEnfermedad) {
                    String[] e2 = dato.split("@");
                    String codigoE = e2[0];
                    String vocabularioE = e2[1];
                    sentenciasSQL.add("INSERT INTO source VALUES (" +
                            "" + vocabularioE + "" +
                            ");");
                    sentenciasSQL.add("INSERT INTO code VALUES (" +
                            "" + codigoE + ", " +
                            "(SELECT source_id FROM source WHERE `name`='" + vocabularioE + "')" +
                            ");");
                    sentenciasSQL.add("INSERT INTO disease_has_code VALUES (" +
                            "(SELECT disease_id FROM disease WHERE `name`='" + nombreEnfermedad + "')," +
                            "" + codigoE + ", " +
                            "(SELECT source_id FROM code WHERE `code`='" + codigoE + "')" +
                            ");");
                }
                String[] s1 = d1[1].split(";");
                for (String dato : s1) {
                    String[] datosSintoma = dato.split(":");
                    String nombreSintoma = datosSintoma[0];
                    String codigoSintoma = datosSintoma[1];
                    String semanticaSintoma = datosSintoma[2];
                    sentenciasSQL.add("INSERT INTO symptom VALUES (" +
                            "" + codigoSintoma + ", " +
                            "" + nombreSintoma + ", " +
                            "" + semanticaSintoma + "" +
                            ");");
                }
            }

            /*
             * Una vez termino el proceso de segmentar e interpretar los datos de disease_data.data, y
             * colectar todas las sentencias de importación correspondientes, se añade al final de esta
             * colección la sentencia COMMIT. Finalmente se procede a ejecutar en orden las sentencias.
             */
            sentenciasSQL.add("COMMIT;");
            for (String sentencia : sentenciasSQL) {
                PreparedStatement ps = connection.prepareStatement(sentencia);
                ps.execute();
            }
        } catch (Exception e) {
            e.printStackTrace();

            /*
             * En caso de un error en el proceso anterior, se parará el progreso y se optará por eliminar totalmente
             * la base de datos, deshaciendo así todos los cambios. Esto ocurre porque se presume que siempre que se
             * ejecute el método crearDB(), no existe la base de datos.
             */
            try {
                PreparedStatement ps = connection.prepareStatement("DROP DATABASE IF EXISTS diagnostico;");
                ps.execute();
            } catch (SQLException ex) {
                System.out.println("No pudo borrarse la base de datos.");
            }
        }
    }

    private void realizarDiagnostico() {
        //TODO: Parte de Dani2.
    }

    /**
     * Método para crear imprimir la lista de síntomas de una enfermedad.
     *
     * @throws Exception Puede lanzar excepción si el proceso de consulta en
     *                   SQL ha fallado o la ID de enfermedad introducida es inválida.
     */
    private void listarSintomasEnfermedad() {
        System.out.println("Escoge una de las siguientes enfermedades introduciendo su ID:");

        /*
         * Se consulta a la base de datos las enfermedades almacenadas y sus IDs correspondientes.
         */
        try {
            PreparedStatement ps = connection.prepareStatement("SELECT disease_id,name FROM disease;");
            ResultSet listadoEnfermedades = ps.executeQuery();
            while (listadoEnfermedades.next()) {
                System.out.println(listadoEnfermedades.getInt("disease_id") + "  |  " +
                        listadoEnfermedades.getString("disease"));
            }

            /*
             * A través de un Scanner, se pide al usuario que introduzca una
             * ID. Acto seguido, se consulta y lista los síntomas de la enfermedad correspondiente.
             */
            Scanner sc = new Scanner(System.in);
            int ID = sc.nextInt();
            PreparedStatement ps2 = connection.prepareStatement(
                    "SELECT name FROM symptom WHERE `cui`=(" +
                            "SELECT cui FROM disease_symptom WHERE `disease_symptom`='" + ID + "');");
            ResultSet listadoSintomas = ps2.executeQuery();
            while (listadoSintomas.next()) {
                System.out.println("* " + listadoSintomas.getString("name"));
            }
        } catch (Exception e) {
            System.out.println("Ha ocurrido un error:");
            e.printStackTrace();
        }
    }

    /**
     * Método para crear imprimir las enfermedades con sus códigos y vocabularios.
     *
     * @throws Exception Puede lanzar excepción si el proceso de consulta en SQL ha fallado.
     */
    private void listarEnfermedadesYCodigosAsociados() {
        System.out.println("Las enfermedades guardadas en la base de datos y sus códigos asociados son:");

        /*
         * Se realiza una consulta a través de la cual se diseña un ResultSet cuya primera columna posee
         * el nombre de la enfermedad, segunda columna el código y tercera columna el vocabulario del código.
         */
        try {
            PreparedStatement ps = connection.prepareStatement(
                    "SELECT disease.name,disease_has_code.code,source.name FROM disease_has_code " +
                            "INNER JOIN disease ON disease_has_code.disease_id=disease.disease_id " +
                            "INNER JOIN source ON disease_has_code.source_id=source.source_id;");
            ResultSet resultados = ps.executeQuery();
            while (resultados.next()) {
                System.out.println(resultados.getString(1) +
                        " | " + resultados.getString(2) +
                        " - " + resultados.getString(3));
            }
        } catch (Exception e) {
            System.out.println("Ha ocurrido un error:");
            e.printStackTrace();
        }
    }

    /**
     * Método para crear imprimir los síntomas y sus tipos semánticos.
     *
     * @throws Exception Puede lanzar excepción si el proceso de consulta en SQL ha fallado.
     */
    private void listarSintomasYTiposSemanticos() {
        System.out.println("Los síntomas guardados en la base de datos y sus tipos semanticos son:");

        /*
         * Se realiza una consulta para obtener todos los síntomas y sus tipos semánticos.
         */
        try {
            PreparedStatement ps = connection.prepareStatement("SELECT name,st FROM symptom;");
            ResultSet resultados = ps.executeQuery();
            while (resultados.next()) {
                System.out.println(resultados.getString("name") +
                        " - " + resultados.getString("st"));
            }
        } catch (SQLException e) {
            System.out.println("Ha ocurrido un error:");
            e.printStackTrace();
        }
    }

    private void mostrarEstadisticasBD() {
        try {
            ArrayList<String> setenciasSQL = new ArrayList<>();
            setenciasSQL.add("SELECT COUNT(disease) FROM disease;");
            setenciasSQL.add("SELECT COUNT(name) FROM symptom;");
            setenciasSQL.add("SELECT disease.name,symptom.name FROM disease_symptom " +
                    "INNER JOIN symptom ON disease_symptom.cui=symptom.cui " +
                    "INNER JOIN disease ON disease_symptom.disease_id=disease.disease_id");

        } catch (Exception e) {

        }
    }

    /**
     * Método para leer números enteros de teclado.
     *
     * @return Devuelve el número leído.
     * @throws Exception Puede lanzar excepción.
     */
    private int readInt() throws Exception {
        try {
            System.out.print("> ");
            return Integer.parseInt(new BufferedReader(new InputStreamReader(System.in)).readLine());
        } catch (Exception e) {
            throw new Exception("Not number.");
        }
    }

    /**
     * Método para leer cadenas de teclado.
     *
     * @return Devuelve la cadena leída.
     * @throws Exception Puede lanzar excepción.
     */
    private String readString() throws Exception {
        try {
            System.out.print("> ");
            return new BufferedReader(new InputStreamReader(System.in)).readLine();
        } catch (Exception e) {
            throw new Exception("Error reading line.");
        }
    }

    /**
     * Método para leer el fichero que contiene los datos.
     *
     * @return Devuelve una lista de String con el contenido.
     * @throws Exception Puede lanzar excepción.
     */
    private LinkedList<String> readData() throws Exception {
        LinkedList<String> data = new LinkedList<String>();
        BufferedReader bL = new BufferedReader(new FileReader(DATAFILE));
        while (bL.ready()) {
            data.add(bL.readLine());
        }
        bL.close();
        return data;
    }

    public static void main(String args[]) {
        new Diagnostico().showMenu();
    }
}