const { Pool } = require('pg');
const fs = require('fs');
const path = require('path');

const pool = new Pool({
  user: 'postgres',
  host: 'localhost',
  database: 'sistema_medico',
  password: '123',
  port: 5432,
});

exports.importDataLiviana = async (req, res) => {
  try {
    const tables = [
      'Diagnostico', 'Empresa', 'Especialidad',
      'Antecedenteheredofamiliar', 'Antecedentenopatologico', 'Antecedentepatologico',
      'Admin', 'Doctor', 'Cliente', 'Especialista',
      'Tipo', 'Tipodos', 'Duracion'
    ];
    let completo = '';
    for (const table of tables) {
      try {
        const filePath = path.join(__dirname, '../data/liviano', `${table}.json`);
        if (!fs.existsSync(filePath)) {
          let mensaje = `Archivo ${table}.json no encontrado`;
          console.log(mensaje);
          completo += mensaje + '\n';
          continue;
        }
        const fileContent = fs.readFileSync(filePath, 'utf8');
        const data = JSON.parse(fileContent);
        if (data.length === 0) {
          let mensaje = `No hay datos para importar en ${table}`;
          console.log(mensaje);
          completo += mensaje + '\n';
          continue;
        }
        // Obtener las columnas del primer registro
        const columns = Object.keys(data[0]);
        const columnNames = columns.map(col => `"${col}"`).join(', ');
        let insertedCount = 0;
        for (const row of data) {
          const values = columns.map(col => row[col]);
          const placeholders = values.map((_, index) => `$${index + 1}`).join(', ');
          const query = `
            INSERT INTO public."${table}" (${columnNames})
            VALUES (${placeholders})
            ON CONFLICT (id) DO NOTHING;
          `;
          await pool.query(query, values);
          insertedCount++;
        }
        let datito = `${insertedCount} registros importados en ${table}`;
        console.log(datito);
        completo += datito + '\n';
      } catch (err) {
        console.error(`Error al importar datos de ${table}:`, err);
        completo += `Error en ${table}: ${err.message}\n`;
      }
    }
    res.json({ message: completo });
  } catch (error) {
    console.error('Error en importDataLiviana:', error);
    res.status(500).json({ message: 'Error al importar datos livianos' });
  }
};

exports.importDataMediano = async (req, res) => {
  try {
    const tables = [
      'Laboratorio', 'Laboratoriodos', 'ItemLaboratorio', 
      'Laboratoriodoscita', 'Analisis', 'Resultado', 
      'Examepaciente', 'Duracioncita',
      'Antecedenteheredofamiliarhistoria', 'Antecedentenopatologicohistoria', 
      'Antecedentepatologicohistoria',
    ];
    let completo = '';    
    for (const table of tables) {
      try {
        const filePath = path.join(__dirname, '../data/mediano', `${table}.json`);
        if (!fs.existsSync(filePath)) {
          let mensaje = `Archivo ${table}.json no encontrado`;
          console.log(mensaje);
          completo += mensaje + '\n';
          continue;
        }
        const fileContent = fs.readFileSync(filePath, 'utf8');
        const data = JSON.parse(fileContent);
        if (data.length === 0) {
          let mensaje = `No hay datos para importar en ${table}`;
          console.log(mensaje);
          completo += mensaje + '\n';
          continue;
        }
        const columns = Object.keys(data[0]);
        const columnNames = columns.map(col => `"${col}"`).join(', ');
        let insertedCount = 0;
        for (const row of data) {
          const values = columns.map(col => row[col]);
          const placeholders = values.map((_, index) => `$${index + 1}`).join(', ');
          const query = `
            INSERT INTO public."${table}" (${columnNames})
            VALUES (${placeholders})
            ON CONFLICT (id) DO NOTHING;
          `;
          await pool.query(query, values);
          insertedCount++;
        }
        let datito = `${insertedCount} registros importados en ${table}`;
        console.log(datito);
        completo += datito + '\n';
      } catch (err) {
        console.error(`Error al importar datos de ${table}:`, err);
        completo += `Error en ${table}: ${err.message}\n`;
      }
    }
    res.json({ message: completo });
  } catch (error) {
    console.error('Error en importDataMediano:', error);
    res.status(500).json({ message: 'Error al importar datos medianos' });
  }
};

exports.importDataMasiva = async (req, res) => {
  try {
    const tables = [
      { name: 'Cita' },
      { name: 'Detallecita' },
      { name: 'Dermatomafrontal' },
      { name: 'Dermatomaposterior' }
    ];
    
    let completo = '';
    
    for (const table of tables) {
      try {
        const filePath = path.join(__dirname, '../data/masivo', `${table.name}.json`);
        
        if (!fs.existsSync(filePath)) {
          let mensaje = `Archivo ${table.name}.json no encontrado`;
          console.log(mensaje);
          completo += mensaje + '\n';
          continue;
        }
        
        const fileContent = fs.readFileSync(filePath, 'utf8');
        const data = JSON.parse(fileContent);
        
        if (data.length === 0) {
          let mensaje = `No hay datos para importar en ${table.name}`;
          console.log(mensaje);
          completo += mensaje + '\n';
          continue;
        }
        
        const columns = Object.keys(data[0]);
        const columnNames = columns.map(col => `"${col}"`).join(', ');
        
        let insertedCount = 0;
        
        for (const row of data) {
          const values = columns.map(col => row[col]);
          const placeholders = values.map((_, index) => `$${index + 1}`).join(', ');
          
          const query = `
            INSERT INTO public."${table.name}" (${columnNames})
            VALUES (${placeholders})
            ON CONFLICT (id) DO NOTHING;
          `;
          
          await pool.query(query, values);
          insertedCount++;
        }
        
        let datito = `${insertedCount} registros importados en ${table.name}`;
        console.log(datito);
        completo += datito + '\n';
        
      } catch (err) {
        console.error(`Error al importar datos de ${table.name}:`, err);
        completo += `Error en ${table.name}: ${err.message}\n`;
      }
    }
    
    res.json({ message: completo });
  } catch (error) {
    console.error('Error en importDataMasiva:', error);
    res.status(500).json({ message: 'Error al importar datos masivos' });
  }
};