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(String database) throws Exception {
        if (connection == null) {
            try {
                Class.forName("com.mysql.jdbc.Driver");
                connection = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/" + database,
                        "root",
                        "");
            } catch (Exception e) {
                System.out.println("Error al conectarse a la base de datos: ");
                e.printStackTrace();
            }
        }
    }

    /**
     * Método para comprobar si la base de datos "diagnostico" existe.
     *
     * @throws Exception Puede lanzar excepción.
     */
    private boolean existeDB() throws Exception {
        boolean ret = false;
        ResultSet r = connection.getMetaData().getCatalogs();
        while (r.next()) {
            if (r.getString(1).equalsIgnoreCase("diagnostico")) {
                ret = true;
            }
        }
        return ret;
    }

    /**
     * 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,
         * se procede a crear la base de datos y las tablas para dejar paso
         * a importación de datos posteriormente.
         */
        try {
            conectar("");
            if (!existeDB()) {
                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 source (" +
                        "source_id INT AUTO_INCREMENT, " +
                        "name VARCHAR(255) UNIQUE, " +
                        "PRIMARY KEY (source_id)" +
                        ");");
                sentenciasSQL.add("CREATE TABLE symptom (" +
                        "cui VARCHAR(25), " +
                        "name VARCHAR(255), " +
                        "st VARCHAR(45), " +
                        "PRIMARY KEY (cui)" +
                        ");");
                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) UNIQUE, " +
                        "source_id INT, " +
                        "PRIMARY KEY (code), " +
                        "FOREIGN KEY (source_id) REFERENCES source(source_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)" +
                        ");");

                /*
                 * 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 (name) VALUES ('" + nombreEnfermedad.replaceAll("'", "''") + "');");
                    String[] datosEnfermedad = e1[1].split(";");
                    for (String dato : datosEnfermedad) {
                        String[] e2 = dato.split("@");
                        String codigoE = e2[0];
                        String sourceE = e2[1];
                        sentenciasSQL.add("INSERT IGNORE INTO source (name) VALUES ('" + sourceE + "');");
                        sentenciasSQL.add("INSERT IGNORE INTO code VALUES ('" + codigoE.replaceAll("'", "''") + "', " +
                                "(SELECT source_id FROM source WHERE `name`='" + sourceE + "'));");
                        sentenciasSQL.add("INSERT INTO disease_has_code VALUES (" +
                                "(SELECT disease_id FROM disease WHERE `name`='" + nombreEnfermedad.replaceAll("'", "''") + "'), " +
                                "'" + codigoE.replaceAll("'", "''") + "', " +
                                "(SELECT source_id FROM code WHERE `code`='" + codigoE.replaceAll("'", "''") + "')" +
                                ");");
                    }
                    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 IGNORE INTO symptom VALUES (" +
                                "'" + codigoSintoma.replaceAll("'", "''") + "', " +
                                "'" + nombreSintoma.replaceAll("'", "''") + "', " +
                                "'" + semanticaSintoma + "'" +
                                ");");
                        sentenciasSQL.add("INSERT INTO disease_symptom VALUES (" +
                                "(SELECT disease_id FROM disease WHERE `name` = '" + nombreEnfermedad.replaceAll("'", "''") + "'), " +
                                "'" + codigoSintoma.replaceAll("'", "''") + "')" +
                                ";");
                    }
                }

                /*
                 * 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();
                }
                connection.setCatalog("diagnostico");
            } else {
                System.out.println("¡La base de datos diagnóstico ya existe!\n");
            }
        } 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() {
        /*try {
            conectar("diagnostico");
            PreparedStatement asktodb = connection.prepareStatement("SELECT cui,name FROM symptom");
            asktodb.execute();

            int[] sympthoms = null;
            sympthoms[0] = -1;
            for (int i = 0; i < sympthoms.length; i++) {
                System.out.println(sympthoms[i]);
            }

            String[] sympcode = readString();

            String[] listofsympthoms = new String[sympcode.length];
            nsymp = sympcode.split(",");
            for (int i = 0; i < nsymp.length; i++) {
                sympcode[i] = "cui= '" + nsymp[i].trim() + "'";
            }
            String query = "SELECT disease_symptom.disease_id,name FROM disease_symptom INNER JOIN disease ON " +
                    "(disease_symptom.disease_id=disease.disease_id) WHERE " + String.join(" OR ", queryList) +
                    " GROUP BY disease_id HAVING count(*)=" + nsymp.length + ";";
            preparedquery = (PreparedStatement) conn.prepareStatement(query);
            System.out.println("Enfermedades para los códigos:" + sympcode + "\n" + executeQuery(query));
        } catch (Exception e) {
            // holi
        }*/
    }

    /**
     * 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 {
            conectar("diagnostico");
            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("name"));
            }

            /*
             * 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 cui FROM disease_symptom WHERE `disease_id`='" + ID + "';");
            ResultSet codigosSintomas = ps2.executeQuery();

            while (codigosSintomas.next()) {
                PreparedStatement ps3 = connection.prepareStatement(
                        "SELECT name FROM symptom WHERE `cui`='" + codigosSintomas.getString("cui") + "'");
                ResultSet sintomas = ps3.executeQuery();
                sintomas.next();
                System.out.println("* " + sintomas.getString("name"));
            }
        } catch (Exception e) {
            System.out.println("Error al ejecutar la opción 4.");
            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:\n");

        /*
         * 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 al listar las enfermedades y sus códigos.");
            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 al listar los síntomas y sus tipos semánticos.");
            e.printStackTrace();
        }
    }

    private void mostrarEstadisticasBD() {
        try {
            conectar("diagnostico");
            PreparedStatement ps = connection.prepareStatement("SELECT COUNT(name) FROM disease;");
            PreparedStatement ps2 = connection.prepareStatement("SELECT COUNT(name) FROM symptom;");
            PreparedStatement ps3 = connection.prepareStatement("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");
            System.out.println("Número enfermedades: " + ps.executeQuery().next());
            System.out.println("Número de síntomas: " + ps2.executeQuery().next());
        } catch (Exception e) {
            System.out.println("Ha ocurrido un error al mostrar las estadísticas.");
            e.printStackTrace();
        }
    }

    /**
     * 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();
    }
}