import Database from 'better-sqlite3';
import { dirname } from 'path';
import { fileURLToPath } from 'url';
import bcrypt from 'bcryptjs';
import { existsSync, mkdirSync } from 'fs';

const __dirname = dirname(fileURLToPath(import.meta.url));
const DB_PATH = __dirname + '/data/hospital.db';

// Ensure data directory exists
if (!existsSync(__dirname + '/data')) {
  mkdirSync(__dirname + '/data', { recursive: true });
}

// Create persistent database connection with WAL mode and proper settings
const db = new Database(DB_PATH);

// Enable WAL mode for better concurrency
db.pragma('journal_mode = WAL');

// Set busy timeout to 5000ms (5 seconds)
db.pragma('busy_timeout = 5000');

// Additional performance and concurrency settings
db.pragma('synchronous = NORMAL');
db.pragma('cache_size = 1000');
db.pragma('temp_store = MEMORY');
db.pragma('mmap_size = 268435456'); // 256MB

export function initDb() {
  db.exec(`
    CREATE TABLE IF NOT EXISTS usuarios (
      id TEXT PRIMARY KEY,
      apellido TEXT NOT NULL,
      nombre TEXT NOT NULL,
      dni TEXT NOT NULL UNIQUE,
      fechaNacimiento TEXT,
      email TEXT,
      rol TEXT,
      matriculaProfesional TEXT,
      passwordHash TEXT,
      areaId TEXT,
      fechaCreacion TEXT
    );

    CREATE TABLE IF NOT EXISTS pacientes (
      id TEXT PRIMARY KEY,
      apellido TEXT NOT NULL,
      nombre TEXT NOT NULL,
      dni TEXT NOT NULL UNIQUE,
      fechaNacimiento TEXT,
      sexo TEXT,
      telefono TEXT,
      email TEXT,
      direccion TEXT,
      obraSocial TEXT,
      nacionalidad TEXT,
      medicacionHabitual TEXT,
      antecedentes TEXT,
      alergias TEXT,
      grupoSanguineo TEXT,
      historiaClinica TEXT
    );

    CREATE TABLE IF NOT EXISTS areas (
      id TEXT PRIMARY KEY,
      nombre TEXT NOT NULL UNIQUE
    );

    CREATE TABLE IF NOT EXISTS grupos (
      id TEXT PRIMARY KEY,
      nombre TEXT NOT NULL UNIQUE
    );

    CREATE TABLE IF NOT EXISTS camas (
      id TEXT PRIMARY KEY,
      numero TEXT NOT NULL,
      grupoId TEXT,
      areaId TEXT,
      tipo TEXT DEFAULT 'Estándar',
      estado TEXT DEFAULT 'Disponible',
      pacienteId TEXT,
      internacionId TEXT
    );

    CREATE TABLE IF NOT EXISTS internaciones (
      id TEXT PRIMARY KEY,
      pacienteId TEXT NOT NULL,
      camaId TEXT,
      grupoId TEXT,
      areaId TEXT,
      fechaIngresoHospital TEXT,
      fechaIngresoClinica TEXT,
      fechaEgreso TEXT,
      diagnosticoIngreso TEXT,
      motivoConsulta TEXT,
      enfermedadActual TEXT,
      antecedentesEnfermedadActual TEXT,
      diagnosticoEgreso TEXT,
      medicoIngresante TEXT,
      motivoEgreso TEXT,
      activa INTEGER DEFAULT 1,
      apache TEXT,
      derivacion TEXT
    );

    CREATE TABLE IF NOT EXISTS evoluciones (
      id TEXT PRIMARY KEY,
      internacionId TEXT NOT NULL,
      fecha TEXT NOT NULL,
      hora TEXT,
      medico TEXT,
      signosVitales TEXT,
      examenFisico TEXT,
      novedades TEXT,
      comentarios TEXT,
      pendientes TEXT
    );

    CREATE TABLE IF NOT EXISTS laboratorios (
      id TEXT PRIMARY KEY,
      pacienteId TEXT NOT NULL,
      internacionId TEXT,
      fecha TEXT NOT NULL,
      hora TEXT,
      tipo TEXT,
      resultados TEXT,
      observaciones TEXT,
      medicoSolicitante TEXT
    );

    CREATE TABLE IF NOT EXISTS glucemias (
      id TEXT PRIMARY KEY,
      pacienteId TEXT NOT NULL,
      internacionId TEXT,
      fecha TEXT NOT NULL,
      hora TEXT,
      valor REAL NOT NULL,
      correccion REAL NOT NULL
    );

    CREATE TABLE IF NOT EXISTS acidosbase (
      id TEXT PRIMARY KEY,
      pacienteId TEXT NOT NULL,
      internacionId TEXT,
      fecha TEXT NOT NULL,
      hora TEXT,
      ph REAL,
      pco2 REAL,
      po2 REAL,
      hco3 REAL,
      be REAL,
      sato2 REAL,
      lactato REAL,
      fio2 REAL,
      interpretacion TEXT
    );

    CREATE TABLE IF NOT EXISTS cultivos (
      id TEXT PRIMARY KEY,
      pacienteId TEXT NOT NULL,
      internacionId TEXT,
      fechaToma TEXT,
      protocolo TEXT,
      fechaResultado TEXT,
      tipoMuestra TEXT,
      germen TEXT,
      sensible TEXT,
      resistente TEXT,
      estado TEXT DEFAULT 'NAF/Pendiente',
      observaciones TEXT
    );

    CREATE TABLE IF NOT EXISTS estudiosComplementarios (
      id TEXT PRIMARY KEY,
      pacienteId TEXT NOT NULL,
      internacionId TEXT,
      fecha TEXT,
      tipo TEXT,
      resultado TEXT
    );

    CREATE TABLE IF NOT EXISTS interconsultas (
      id TEXT PRIMARY KEY,
      pacienteId TEXT NOT NULL,
      internacionId TEXT NOT NULL,
      fecha TEXT,
      servicioInterconsultado TEXT,
      motivo TEXT,
      respuestaInterconsulta TEXT,
      respuestaFecha TEXT
    );

    CREATE TABLE IF NOT EXISTS atb (
      id TEXT PRIMARY KEY,
      pacienteId TEXT NOT NULL,
      internacionId TEXT NOT NULL,
      antibiotico TEXT,
      fechaInicio TEXT,
      fechaFinalizacion TEXT
    );

    CREATE TABLE IF NOT EXISTS indicaciones (
      id TEXT PRIMARY KEY,
      internacionId TEXT NOT NULL,
      tipo TEXT NOT NULL,
      droga TEXT,
      dosis TEXT,
      frecuenciaHoras INTEGER,
      via TEXT,
      indicacionNoFco TEXT,
      tipoPlan TEXT,
      tipoPlan2 TEXT,
      cantidadMl INTEGER,
      cantidadMl2 INTEGER,
      tiempoHoras INTEGER,
      tipoInsulina TEXT,
      unidadesDesayuno INTEGER,
      unidadesAlmuerzo INTEGER,
      unidadesNoche INTEGER,
      estado TEXT DEFAULT 'Activa',
      medicoCrea TEXT,
      fechaCrea TEXT
    );

    CREATE TABLE IF NOT EXISTS movimientos_indicaciones (
      id TEXT PRIMARY KEY,
      indicacionId TEXT NOT NULL,
      internacionId TEXT NOT NULL,
      tipo TEXT NOT NULL,
      fecha TEXT NOT NULL,
      profesional TEXT NOT NULL,
      indicacionPrevia TEXT,
      indicacionNueva TEXT
    );

    CREATE TABLE IF NOT EXISTS kv (
      key TEXT PRIMARY KEY,
      value TEXT
    );
  `);

  // Migration helpers for columns if existing DB
  try { db.exec('ALTER TABLE usuarios ADD COLUMN grupoId TEXT;'); } catch (_) {}
  try { db.exec('ALTER TABLE camas ADD COLUMN grupoId TEXT;'); } catch (_) {}
  try { db.exec('ALTER TABLE internaciones ADD COLUMN grupoId TEXT;'); } catch (_) {}
  try { db.exec('ALTER TABLE usuarios ADD COLUMN areaId TEXT;'); } catch (_) {}
  try { db.exec('ALTER TABLE camas ADD COLUMN areaId TEXT;'); } catch (_) {}
  try { db.exec('ALTER TABLE internaciones ADD COLUMN areaId TEXT;'); } catch (_) {}

  // Seed default 4 grupos if empty
  try {
    const defaultGrupos = [
      { id: 'patron-fondo', nombre: 'Patron Fondo' },
      { id: 'patron-adelante', nombre: 'Patron Adelante' },
      { id: 'segundo-acassuso', nombre: 'Segundo Acassuso' },
      { id: 'tercero-acassuso', nombre: 'Tercero Acassuso' }
    ];

    const grupoCount = db.prepare('SELECT COUNT(*) as count FROM grupos').get();
    if (!grupoCount || grupoCount.count === 0) {
      const stmtG = db.prepare('INSERT OR IGNORE INTO grupos (id, nombre) VALUES (?, ?)');
      const stmtA = db.prepare('INSERT OR IGNORE INTO areas (id, nombre) VALUES (?, ?)');
      for (const g of defaultGrupos) {
        stmtG.run(g.id, g.nombre);
        stmtA.run(g.id, g.nombre);
      }
    }
  } catch (err) {
    console.error('Error seeding default grupos:', err);
  }

  // Create default admin if no users exist
  try {
    const userCount = db.prepare('SELECT COUNT(*) as count FROM usuarios').get();
    if (!userCount || userCount.count === 0) {
      const adminHash = bcrypt.hashSync('admin123', 10);
      db.prepare(`
        INSERT INTO usuarios (id, apellido, nombre, dni, fechaNacimiento, email, rol, passwordHash, fechaCreacion)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
      `).run('admin-default', 'Administrador', 'Sistema', '12345678', '1990-01-01', 'admin@hospital.local', 'admin', adminHash, new Date().toISOString().split('T')[0]);
      console.log('Usuario admin por defecto creado: DNI 12345678 / Clave admin123');
    }
  } catch (err) {
    console.error('Error al verificar usuario admin por defecto:', err);
  }
}

// Auto-initialize tables
initDb();

export function getDb() {
  return db;
}

function rowToObj(row) {
  if (!row) return row;
  const obj = {};
  for (const key in row) {
    const val = row[key];
    try {
      obj[key] = typeof val === 'string' && (val.startsWith('[') || val.startsWith('{')) ? JSON.parse(val) : val;
    } catch {
      obj[key] = val;
    }
  }
  return obj;
}

export function getValue(key) {
  const row = db.prepare('SELECT value FROM kv WHERE key = ?').get(key);
  return row?.value ?? null;
}

export function setValue(key, value) {
  const stmt = db.prepare('INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value');
  stmt.run(key, value);
}

export function getUsuarioByDni(dni) {
  const row = db.prepare('SELECT * FROM usuarios WHERE dni = ?').get(dni);
  return row || null;
}

export function getUsuarioById(id) {
  const row = db.prepare('SELECT * FROM usuarios WHERE id = ?').get(id);
  return row || null;
}

export function getAllUsuarios() {
  const rows = db.prepare('SELECT * FROM usuarios ORDER BY apellido, nombre').all();
  return rows;
}

export function createUsuario(usuario) {
  const stmt = db.prepare(`INSERT INTO usuarios (id, apellido, nombre, dni, fechaNacimiento, email, rol, matriculaProfesional, passwordHash, areaId, fechaCreacion)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
  stmt.run(
    usuario.id,
    usuario.apellido,
    usuario.nombre,
    usuario.dni,
    usuario.fechaNacimiento,
    usuario.email,
    usuario.rol,
    usuario.matriculaProfesional || null,
    usuario.passwordHash,
    usuario.areaId || null,
    usuario.fechaCreacion
  );
}

export function updateUsuario(id, datos) {
  const fields = [];
  const values = [];
  
  if (datos.apellido !== undefined) { fields.push('apellido = ?'); values.push(datos.apellido); }
  if (datos.nombre !== undefined) { fields.push('nombre = ?'); values.push(datos.nombre); }
  if (datos.fechaNacimiento !== undefined) { fields.push('fechaNacimiento = ?'); values.push(datos.fechaNacimiento); }
  if (datos.email !== undefined) { fields.push('email = ?'); values.push(datos.email); }
  if (datos.rol !== undefined) { fields.push('rol = ?'); values.push(datos.rol); }
  if (datos.matriculaProfesional !== undefined) { fields.push('matriculaProfesional = ?'); values.push(datos.matriculaProfesional); }
  if (datos.passwordHash !== undefined) { fields.push('passwordHash = ?'); values.push(datos.passwordHash); }
  if (datos.areaId !== undefined) { fields.push('areaId = ?'); values.push(datos.areaId); }
  
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE usuarios SET ${fields.join(', ')} WHERE id = ?`).run(values);
  }
}

export function deleteUsuario(id) {
  db.prepare('DELETE FROM usuarios WHERE id = ?').run(id);
}

export function verifyPassword(dni, password) {
  const row = db.prepare('SELECT passwordHash FROM usuarios WHERE dni = ?').get(dni);
  if (!row) return false;
  return bcrypt.compareSync(password, row.passwordHash);
}

export function hashPassword(password) {
  return bcrypt.hashSync(password, 10);
}

export function getAllPacientes() {
  const rows = db.prepare('SELECT * FROM pacientes').all();
  return rows;
}

export function getAllGrupos() {
  const rows = db.prepare('SELECT * FROM grupos').all();
  if (!rows || rows.length === 0) {
    return db.prepare('SELECT * FROM areas').all();
  }
  return rows;
}

export function getAllAreas() {
  return getAllGrupos();
}

export function getAllCamas() {
  const rows = db.prepare('SELECT * FROM camas').all();
  return rows;
}

export function updateCama(id, updates) {
  const fields = [];
  const values = [];
  if (updates.estado !== undefined) {
    fields.push('estado = ?');
    values.push(updates.estado);
  }
  if (updates.pacienteId !== undefined) {
    fields.push('pacienteId = ?');
    values.push(updates.pacienteId);
  }
  if (updates.internacionId !== undefined) {
    fields.push('internacionId = ?');
    values.push(updates.internacionId);
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE camas SET ${fields.join(', ')} WHERE id = ?`).run(values);
  }
}

export function getAllInternaciones() {
  const rows = db.prepare('SELECT * FROM internaciones').all();
  return rows.map(i => ({ ...i, activa: !!i.activa }));
}

export function getAllEvoluciones() {
  const rows = db.prepare('SELECT * FROM evoluciones').all();
  return rows.map(e => ({
    ...e,
    comentario: e.comentarios || e.comentario || '',
    signosVitales: typeof e.signosVitales === 'string' ? JSON.parse(e.signosVitales) : e.signosVitales,
    examenFisico: typeof e.examenFisico === 'string' ? JSON.parse(e.examenFisico) : e.examenFisico
  }));
}

export function getAllLaboratorios() {
  const rows = db.prepare('SELECT * FROM laboratorios').all();
  return rows.map(l => ({ ...l, resultados: typeof l.resultados === 'string' ? JSON.parse(l.resultados) : l.resultados }));
}

export function getAllGlucemias() {
  const rows = db.prepare('SELECT * FROM glucemias').all();
  return rows;
}

export function getAllAcidosBase() {
  const rows = db.prepare('SELECT * FROM acidosbase').all();
  return rows;
}

export function getAllCultivos() {
  const rows = db.prepare('SELECT * FROM cultivos').all();
  return rows;
}

export function getAllEstudiosComplementarios() {
  const rows = db.prepare('SELECT * FROM estudiosComplementarios').all();
  return rows;
}

export function getAllInterconsultas() {
  const rows = db.prepare('SELECT * FROM interconsultas').all();
  return rows.map(ic => ({ ...ic, realizada: !!ic.realizada }));
}

export function getAllAtb() {
  const rows = db.prepare('SELECT * FROM atb').all();
  return rows;
}

export function getAllIndicaciones() {
  const rows = db.prepare('SELECT * FROM indicaciones').all();
  return rows;
}

export function getAllMovimientosIndicaciones() {
  const rows = db.prepare('SELECT * FROM movimientos_indicaciones').all();
  return rows;
}

// Pacientes
export function createPaciente(p) {
  const stmt = db.prepare('INSERT INTO pacientes (id, apellido, nombre, dni, fechaNacimiento, sexo, telefono, email, direccion, obraSocial, nacionalidad, medicacionHabitual, antecedentes, alergias, grupoSanguineo, historiaClinica) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
  stmt.run(p.id, p.apellido, p.nombre, p.dni, p.fechaNacimiento || null, p.sexo || null, p.telefono || null, p.email || null, p.direccion || null, p.obraSocial || null, p.nacionalidad || null, p.medicacionHabitual || null, p.antecedentes || null, p.alergias || null, p.grupoSanguineo || null, p.historiaClinica || null);
}

export function updatePaciente(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      fields.push(`${key} = ?`);
      values.push(val);
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE pacientes SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deletePaciente(id) {
  db.prepare('DELETE FROM pacientes WHERE id = ?').run(id);
}

// Grupos & Areas
export function createGrupo(grupo) {
  const stmtG = db.prepare('INSERT INTO grupos (id, nombre) VALUES (?, ?)');
  const stmtA = db.prepare('INSERT INTO areas (id, nombre) VALUES (?, ?)');
  stmtG.run(grupo.id, grupo.nombre);
  try { stmtA.run(grupo.id, grupo.nombre); } catch (_) {}
}

export function updateGrupo(id, datos) {
  if (datos.nombre) {
    db.prepare('UPDATE grupos SET nombre = ? WHERE id = ?').run(datos.nombre, id);
    try { db.prepare('UPDATE areas SET nombre = ? WHERE id = ?').run(datos.nombre, id); } catch (_) {}
  }
}

export function deleteGrupo(id) {
  db.prepare('DELETE FROM grupos WHERE id = ?').run(id);
  try { db.prepare('DELETE FROM areas WHERE id = ?').run(id); } catch (_) {}
}

export function createArea(area) {
  createGrupo(area);
}

export function updateArea(id, datos) {
  updateGrupo(id, datos);
}

export function deleteArea(id) {
  deleteGrupo(id);
}

// Camas
export function createCama(cama) {
  const gId = cama.grupoId || cama.areaId || null;
  db.prepare('INSERT INTO camas (id, numero, grupoId, areaId, tipo, estado, pacienteId, internacionId) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(cama.id, cama.numero, gId, gId, cama.tipo || 'Estándar', cama.estado || 'Disponible', cama.pacienteId || null, cama.internacionId || null);
}

export function deleteCama(id) {
  db.prepare('DELETE FROM camas WHERE id = ?').run(id);
}

// Internaciones
export function createInternacion(i) {
  const gId = i.grupoId || i.areaId || null;
  const stmt = db.prepare('INSERT INTO internaciones (id, pacienteId, camaId, grupoId, areaId, fechaIngresoHospital, fechaIngresoClinica, fechaEgreso, diagnosticoIngreso, motivoConsulta, enfermedadActual, antecedentesEnfermedadActual, diagnosticoEgreso, medicoIngresante, motivoEgreso, activa, apache, derivacion) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
  stmt.run(i.id, i.pacienteId, i.camaId || null, gId, gId, i.fechaIngresoHospital || null, i.fechaIngresoClinica || null, i.fechaEgreso || null, i.diagnosticoIngreso || null, i.motivoConsulta || null, i.enfermedadActual || null, i.antecedentesEnfermedadActual || null, i.diagnosticoEgreso || null, i.medicoIngresante || null, i.motivoEgreso || null, i.activa ? 1 : 0, i.apache || null, i.derivacion || null);
}

export function updateInternacion(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      if (key === 'activa') {
        fields.push('activa = ?');
        values.push(val ? 1 : 0);
      } else {
        fields.push(`${key} = ?`);
        values.push(val);
      }
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE internaciones SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deleteInternacion(id) {
  db.prepare('DELETE FROM internaciones WHERE id = ?').run(id);
}

// Evoluciones
export function createEvolucion(e) {
  const stmt = db.prepare('INSERT INTO evoluciones (id, internacionId, fecha, hora, medico, signosVitales, examenFisico, novedades, comentarios, pendientes) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
  stmt.run(e.id, e.internacionId, e.fecha, e.hora || '', e.medico || '', JSON.stringify(e.signosVitales || {}), JSON.stringify(e.examenFisico || {}), e.novedades || '', e.comentarios || e.comentario || '', e.pendientes || '');
}

export function updateEvolucion(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      if (key === 'comentario') {
        fields.push('comentarios = ?');
        values.push(val);
      } else if (key === 'signosVitales' || key === 'examenFisico') {
        fields.push(`${key} = ?`);
        values.push(JSON.stringify(val));
      } else {
        fields.push(`${key} = ?`);
        values.push(val);
      }
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE evoluciones SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deleteEvolucion(id) {
  db.prepare('DELETE FROM evoluciones WHERE id = ?').run(id);
}

// Laboratorios
export function createLaboratorio(l) {
  const stmt = db.prepare('INSERT INTO laboratorios (id, pacienteId, internacionId, fecha, hora, tipo, resultados, observaciones, medicoSolicitante) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)');
  stmt.run(l.id, l.pacienteId, l.internacionId || null, l.fecha, l.hora || null, l.tipo || null, JSON.stringify(l.resultados || {}), l.observaciones || null, l.medicoSolicitante || null);
}

export function updateLaboratorio(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      if (key === 'resultados') {
        fields.push('resultados = ?');
        values.push(JSON.stringify(val));
      } else {
        fields.push(`${key} = ?`);
        values.push(val);
      }
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE laboratorios SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deleteLaboratorio(id) {
  db.prepare('DELETE FROM laboratorios WHERE id = ?').run(id);
}

// Glucemias
export function createGlucemia(g) {
  const stmt = db.prepare('INSERT INTO glucemias (id, pacienteId, internacionId, fecha, hora, valor, correccion) VALUES (?, ?, ?, ?, ?, ?, ?)');
  stmt.run(g.id, g.pacienteId, g.internacionId || null, g.fecha, g.hora || null, g.valor, g.correccion);
}

export function updateGlucemia(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      fields.push(`${key} = ?`);
      values.push(val);
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE glucemias SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deleteGlucemia(id) {
  db.prepare('DELETE FROM glucemias WHERE id = ?').run(id);
}

// AcidosBase
export function createAcidoBase(a) {
  const stmt = db.prepare('INSERT INTO acidosbase (id, pacienteId, internacionId, fecha, hora, ph, pco2, po2, hco3, be, sato2, lactato, fio2, interpretacion) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
  stmt.run(a.id, a.pacienteId, a.internacionId || null, a.fecha, a.hora || null, a.ph, a.pco2, a.po2, a.hco3, a.be, a.sato2, a.lactato || null, a.fio2 || null, a.interpretacion || null);
}

export function updateAcidoBase(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      fields.push(`${key} = ?`);
      values.push(val);
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE acidosbase SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deleteAcidoBase(id) {
  db.prepare('DELETE FROM acidosbase WHERE id = ?').run(id);
}

// Cultivos
export function createCultivo(c) {
  const stmt = db.prepare('INSERT INTO cultivos (id, pacienteId, internacionId, fechaToma, protocolo, fechaResultado, tipoMuestra, germen, sensible, resistente, estado, observaciones) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
  stmt.run(c.id, c.pacienteId, c.internacionId || null, c.fechaToma || null, c.protocolo || null, c.fechaResultado || null, c.tipoMuestra || null, c.germen || null, c.sensible || null, c.resistente || null, c.estado || 'NAF/Pendiente', c.observaciones || null);
}

export function updateCultivo(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      fields.push(`${key} = ?`);
      values.push(val);
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE cultivos SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deleteCultivo(id) {
  db.prepare('DELETE FROM cultivos WHERE id = ?').run(id);
}

// Estudios Complementarios
export function createEstudioComplementario(e) {
  const stmt = db.prepare('INSERT INTO estudiosComplementarios (id, pacienteId, internacionId, fecha, tipo, resultado) VALUES (?, ?, ?, ?, ?, ?)');
  stmt.run(e.id, e.pacienteId, e.internacionId || null, e.fecha || null, e.tipo || null, e.resultado || null);
}

export function updateEstudioComplementario(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      fields.push(`${key} = ?`);
      values.push(val);
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE estudiosComplementarios SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deleteEstudioComplementario(id) {
  db.prepare('DELETE FROM estudiosComplementarios WHERE id = ?').run(id);
}

// Interconsultas
export function createInterconsulta(ic) {
  const stmt = db.prepare('INSERT INTO interconsultas (id, pacienteId, internacionId, fecha, servicioInterconsultado, motivo, respuestaInterconsulta, respuestaFecha) VALUES (?, ?, ?, ?, ?, ?, ?, ?)');
  stmt.run(ic.id, ic.pacienteId, ic.internacionId, ic.fecha || null, ic.servicioInterconsultado, ic.motivo || null, ic.respuestaInterconsulta || null, ic.respuestaFecha || null);
}

export function updateInterconsulta(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      fields.push(`${key} = ?`);
      values.push(val);
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE interconsultas SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deleteInterconsulta(id) {
  db.prepare('DELETE FROM interconsultas WHERE id = ?').run(id);
}

// ATB
export function createAtb(a) {
  const stmt = db.prepare('INSERT INTO atb (id, pacienteId, internacionId, antibiotico, fechaInicio, fechaFinalizacion) VALUES (?, ?, ?, ?, ?, ?)');
  stmt.run(a.id, a.pacienteId, a.internacionId, a.antibiotico || null, a.fechaInicio || null, a.fechaFinalizacion || null);
}

export function updateAtb(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      fields.push(`${key} = ?`);
      values.push(val);
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE atb SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deleteAtb(id) {
  db.prepare('DELETE FROM atb WHERE id = ?').run(id);
}

// Indicaciones
export function createIndicacion(ind) {
  const stmt = db.prepare('INSERT INTO indicaciones (id, internacionId, tipo, droga, dosis, frecuenciaHoras, via, indicacionNoFco, tipoPlan, tipoPlan2, cantidadMl, cantidadMl2, tiempoHoras, tipoInsulina, unidadesDesayuno, unidadesAlmuerzo, unidadesNoche, estado, medicoCrea, fechaCrea) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
  stmt.run(ind.id, ind.internacionId, ind.tipo, ind.droga || null, ind.dosis || null, ind.frecuenciaHoras || null, ind.via || null, ind.indicacionNoFco || null, ind.tipoPlan || null, ind.tipoPlan2 || null, ind.cantidadMl || null, ind.cantidadMl2 || null, ind.tiempoHoras || null, ind.tipoInsulina || null, ind.unidadesDesayuno || null, ind.unidadesAlmuerzo || null, ind.unidadesNoche || null, ind.estado || 'Activa', ind.medicoCrea || null, ind.fechaCrea || null);
}

export function updateIndicacion(id, datos) {
  const fields = [];
  const values = [];
  for (const [key, val] of Object.entries(datos)) {
    if (key !== 'id' && val !== undefined) {
      fields.push(`${key} = ?`);
      values.push(val);
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE indicaciones SET ${fields.join(', ')} WHERE id = ?`).run(...values);
  }
}

export function deleteIndicacion(id) {
  db.prepare('DELETE FROM indicaciones WHERE id = ?').run(id);
}

// Movimientos Indicaciones
export function createMovimientoIndicacion(m) {
  const stmt = db.prepare('INSERT INTO movimientos_indicaciones (id, indicacionId, internacionId, tipo, fecha, profesional, indicacionPrevia, indicacionNueva) VALUES (?, ?, ?, ?, ?, ?, ?, ?)');
  stmt.run(
    m.id,
    m.indicacionId || '',
    m.internacionId || '',
    m.tipo || '',
    m.fecha || new Date().toISOString(),
    m.profesional || '',
    m.indicacionPrevia || null,
    m.indicacionNueva || null
  );
}