import type { Request, Response, NextFunction } from 'express';
import * as cfdiService from '../services/cfdi.service.js';
import { AppError } from '../middlewares/error.middleware.js';
import { GRUPO_PF_EMPRESARIAL, GRUPO_PM_OTROS } from '../services/dashboard.service.js';
import { getRegimenesIgnoradosClaves } from '../services/regimen.service.js';
import { resolveContribuyenteContext } from '../utils/contribuyente-context.js';
import type { CfdiFilters } from '@horux/shared';

export async function getCfdis(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    const filters: CfdiFilters = {
      tipo: req.query.tipo as any,
      estado: req.query.estado as any,
      fechaInicio: req.query.fechaInicio as string,
      fechaFin: req.query.fechaFin as string,
      rfc: req.query.rfc as string,
      emisor: req.query.emisor as string,
      receptor: req.query.receptor as string,
      search: req.query.search as string,
      contribuyenteId: req.query.contribuyenteId as string,
      page: parseInt(req.query.page as string) || 1,
      limit: parseInt(req.query.limit as string) || 20,
    };

    const result = await cfdiService.getCfdis(req.tenantPool, filters);
    res.json(result);
  } catch (error) {
    next(error);
  }
}

export async function getCfdiById(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    const cfdi = await cfdiService.getCfdiById(req.tenantPool, String(req.params.id));

    if (!cfdi) {
      return next(new AppError(404, 'CFDI no encontrado'));
    }

    res.json(cfdi);
  } catch (error) {
    next(error);
  }
}

export async function getXml(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    const xml = await cfdiService.getXmlById(req.tenantPool, String(req.params.id));

    if (!xml) {
      return next(new AppError(404, 'XML no encontrado para este CFDI'));
    }

    res.set('Content-Type', 'application/xml');
    res.set('Content-Disposition', `attachment; filename="cfdi-${req.params.id}.xml"`);
    res.send(xml);
  } catch (error) {
    next(error);
  }
}

export async function getConceptos(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    const conceptos = await cfdiService.getConceptos(req.tenantPool, String(req.params.id));
    res.json(conceptos);
  } catch (error) {
    next(error);
  }
}

export async function drillDown(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    const {
      fechaInicio, fechaFin, type, tipoComprobante, metodoPago,
      regimenEmisor, regimenReceptor, status, contribuyenteId,
      bucket,
    } = req.query;

    let where = 'WHERE 1=1';
    const params: any[] = [];
    let pi = 1;

    // `bucket` expande la combinación (type, tipo_comprobante, metodo_pago,
    // régimen) exactamente igual a la fórmula de KPIs/tarjetas — para que
    // el drill-down cuadre línea a línea con el total del header.
    //
    // Reglas por bucket (alineado con dashboard.service y impuestos.service):
    //   ingresos: 3 grupos de régimen del emisor con fórmulas distintas.
    //     Grupo 1 (PF Empresarial 606/612/621/625/626):
    //       EMIT I PUE + EMIT P + EMIT E PUE (excl. E/07)
    //     Grupo 2 (Sueldos 605, recibido como N):
    //       RECIB N PUE con receptor=605
    //     Grupo 3 (PM y otros): EMIT I PUE+PPD + EMIT E PUE
    //   gastos:  uniforme todos los regímenes del receptor
    //       RECIB I PUE + RECIB P + RECIB E PUE (excl. E/07)
    //   causado (IVA): EMIT I PUE + EMIT P + EMIT E PUE (excl. E/07)
    //   acreditable (IVA): RECIB I PUE + RECIB P + RECIB E PUE (excl. E/07)
    //
    // Régimenes "ignorados" por el tenant se excluyen en todos los buckets.
    // Las NC que restan se muestran como filas con signo (frontend las resta
    // del total del header). Si `bucket` se pasa, se ignoran filtros
    // type/tipoComprobante/metodoPago de entrada.
    const bucketStr = typeof bucket === 'string' ? bucket.toLowerCase() : '';
    const bucketApplied = bucketStr === 'ingresos' || bucketStr === 'gastos' ||
                          bucketStr === 'causado'  || bucketStr === 'acreditable';

    // Régimenes ignorados por el tenant (configurable en /regimenes). Se
    // excluyen del lado correspondiente según el bucket.
    const ignorados = req.user?.tenantId
      ? await getRegimenesIgnoradosClaves(req.user.tenantId)
      : [];

    // Resolver condiciones esEmisor/esReceptor basadas en RFC del contribuyente.
    // Reemplaza `type = 'EMITIDO/RECIBIDO' AND contribuyente_id = X` por un
    // filtro por RFC — fuente de verdad cuando dos contribuyentes del tenant
    // se facturan entre sí (type/contribuyente_id pueden ser inconsistentes).
    const contribIdStr = typeof contribuyenteId === 'string' ? contribuyenteId : undefined;
    const cfdiCtx = req.user?.tenantId
      ? await resolveContribuyenteContext(req.tenantPool, req.user.tenantId, contribIdStr)
      : null;
    const esEmisor = cfdiCtx?.esEmisor || `type = 'EMITIDO'`;
    const esReceptor = cfdiCtx?.esReceptor || `type = 'RECIBIDO'`;

    const NO_IGNORADO_EMISOR = ignorados.length > 0
      ? `AND (regimen_fiscal_emisor IS NULL OR regimen_fiscal_emisor NOT IN (${ignorados.map(r => `'${r}'`).join(',')}))`
      : '';
    const NO_IGNORADO_RECEPTOR = ignorados.length > 0
      ? `AND (regimen_fiscal_receptor IS NULL OR regimen_fiscal_receptor NOT IN (${ignorados.map(r => `'${r}'`).join(',')}))`
      : '';

    const g1 = GRUPO_PF_EMPRESARIAL.map(r => `'${r}'`).join(',');
    const g3 = GRUPO_PM_OTROS.map(r => `'${r}'`).join(',');
    // Conjunto canónico de regímenes que el dashboard considera (excluye 616
    // extranjero y otros fuera del catálogo). El drill debe respetarlo para
    // cuadrar con los KPIs/tarjetas.
    const TODOS_REGS = [...GRUPO_PF_EMPRESARIAL, '605', ...GRUPO_PM_OTROS]
      .map(r => `'${r}'`)
      .join(',');
    const E_NO_ANTICIPO = `COALESCE(cfdi_tipo_relacion, '') <> '07'`;

    if (bucketStr === 'ingresos') {
      // 3 grupos con fórmulas distintas. Filtro por RFC (esEmisor/esReceptor).
      // Grupo 1 usa Método A: todas las I/07 y E/07 se incluyen (sin filtro
      // `E_NO_ANTICIPO`) — la suma algebraica se neutraliza correctamente
      // cuando anticipo, I/07 y E/07 están en el mismo universo de la query.
      where += ` AND (
        ( -- Grupo 1 PF Empresarial
          ${esEmisor}
          AND regimen_fiscal_emisor IN (${g1})
          AND (
            (tipo_comprobante = 'I' AND metodo_pago = 'PUE')
            OR (tipo_comprobante = 'P')
            OR (tipo_comprobante = 'E' AND metodo_pago = 'PUE')
          )
        )
        OR ( -- Grupo 2 Sueldos: nómina recibida 605
          ${esReceptor}
          AND tipo_comprobante = 'N'
          AND metodo_pago = 'PUE'
          AND regimen_fiscal_receptor = '605'
        )
        OR ( -- Grupo 3 PM y otros
          ${esEmisor}
          AND regimen_fiscal_emisor IN (${g3})
          AND (
            (tipo_comprobante = 'I' AND metodo_pago IN ('PUE','PPD'))
            OR (tipo_comprobante = 'E' AND metodo_pago = 'PUE')
          )
        )
      ) ${NO_IGNORADO_EMISOR.replace('regimen_fiscal_emisor', `CASE WHEN ${esEmisor} THEN regimen_fiscal_emisor ELSE regimen_fiscal_receptor END`)}`;
    } else if (bucketStr === 'gastos') {
      // Método A: sin E_NO_ANTICIPO — las E/07 también aparecen en el
      // drill (restan del gasto al igual que en el KPI).
      where += ` AND (
        ${esReceptor} AND (
          (tipo_comprobante = 'I' AND metodo_pago = 'PUE')
          OR (tipo_comprobante = 'P')
          OR (tipo_comprobante = 'E' AND metodo_pago = 'PUE')
        )
        AND regimen_fiscal_receptor IN (${TODOS_REGS})
      ) ${NO_IGNORADO_RECEPTOR}`;
    } else if (bucketStr === 'causado') {
      where += ` AND (
        ${esEmisor} AND (
          (tipo_comprobante = 'I' AND metodo_pago = 'PUE')
          OR (tipo_comprobante = 'P')
          OR (tipo_comprobante = 'E' AND metodo_pago = 'PUE' AND ${E_NO_ANTICIPO})
        )
        AND regimen_fiscal_emisor IN (${TODOS_REGS})
      ) ${NO_IGNORADO_EMISOR}`;
    } else if (bucketStr === 'acreditable') {
      where += ` AND (
        ${esReceptor} AND (
          (tipo_comprobante = 'I' AND metodo_pago = 'PUE')
          OR (tipo_comprobante = 'P')
          OR (tipo_comprobante = 'E' AND metodo_pago = 'PUE' AND ${E_NO_ANTICIPO})
        )
        AND regimen_fiscal_receptor IN (${TODOS_REGS})
      ) ${NO_IGNORADO_RECEPTOR}`;
    }

    // Fecha efectiva: para CFDIs tipo P (complementos de pago) usa fecha_pago_p
    // (cuándo el cliente cobró) en vez de fecha_emision (cuándo se emitió el
    // complemento). Así el drill-down es coherente con los KPIs — un P emitido
    // en mayo que cobró una PPD de noviembre aparece en noviembre, no en mayo.
    const FECHA_EFECTIVA = `CASE WHEN tipo_comprobante = 'P' THEN fecha_pago_p ELSE fecha_emision END`;
    if (fechaInicio) {
      where += ` AND ${FECHA_EFECTIVA} >= $${pi++}::date`;
      params.push(fechaInicio);
    }
    if (fechaFin) {
      where += ` AND ${FECHA_EFECTIVA} < ($${pi++}::date + interval '1 day')`;
      params.push(fechaFin);
    }
    if (!bucketApplied) {
      if (type) {
        where += ` AND type = $${pi++}`;
        params.push(type);
      }
      // tipoComprobante acepta valor único ('I') o CSV ('I,P'). Cuando la lista
      // incluye P, el filtro metodoPago NO se aplica a los P (que no tienen),
      // para que un drill-down "Ingresos del Mes" muestre I PUE + todos los P.
      const tiposList = tipoComprobante
        ? (tipoComprobante as string).split(',').map(t => t.trim()).filter(Boolean)
        : [];
      const includesP = tiposList.includes('P');
      if (tiposList.length === 1) {
        where += ` AND tipo_comprobante = $${pi++}`;
        params.push(tiposList[0]);
      } else if (tiposList.length > 1) {
        where += ` AND tipo_comprobante = ANY($${pi++})`;
        params.push(tiposList);
      }
      if (metodoPago) {
        const metodos = (metodoPago as string).split(',');
        if (includesP) {
          // P no tiene metodo_pago: el filtro aplica solo a los no-P
          where += ` AND (tipo_comprobante = 'P' OR metodo_pago = ANY($${pi++}))`;
          params.push(metodos);
        } else {
          where += ` AND metodo_pago = ANY($${pi++})`;
          params.push(metodos);
        }
      }
    }
    if (regimenEmisor) {
      where += ` AND regimen_fiscal_emisor = $${pi++}`;
      params.push(regimenEmisor);
    }
    if (regimenReceptor) {
      where += ` AND regimen_fiscal_receptor = $${pi++}`;
      params.push(regimenReceptor);
    }
    if (status) {
      if (status === 'vigente') {
        where += ` AND status NOT IN ('Cancelado', '0')`;
      } else {
        where += ` AND status IN ('Cancelado', '0')`;
      }
    }
    if (contribuyenteId && !bucketApplied) {
      // Solo aplica cuando NO hay bucket (drill crudo, sin semantic de lado).
      // Con bucket, esEmisor/esReceptor ya restringen por RFC del contribuyente.
      // Sin bucket, filtramos inclusivo: contribuyente_id O RFC en cualquier lado.
      if (cfdiCtx) {
        where += ` AND ${cfdiCtx.contribFilter.replace(/^AND /, '')}`;
      }
    }

    const { rows } = await req.tenantPool.query(`
      SELECT id, uuid, type, tipo_comprobante as "tipoComprobante",
        fecha_emision as "fechaEmision", status,
        rfc_emisor as "rfcEmisor", nombre_emisor as "nombreEmisor",
        rfc_receptor as "rfcReceptor", nombre_receptor as "nombreReceptor",
        subtotal, subtotal_mxn as "subtotalMxn",
        total, total_mxn as "totalMxn",
        moneda, metodo_pago as "metodoPago",
        iva_traslado_mxn as "ivaTrasladoMxn",
        iva_retencion_mxn as "ivaRetencionMxn",
        isr_retencion_mxn as "isrRetencionMxn",
        monto_pago_mxn as "montoPagoMxn",
        regimen_fiscal_emisor as "regimenEmisor",
        regimen_fiscal_receptor as "regimenReceptor"
      FROM cfdis
      ${where}
      ORDER BY fecha_emision DESC
      LIMIT 500
    `, params);

    res.json(rows);
  } catch (error) {
    next(error);
  }
}

export async function getEmisores(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    const search = (req.query.search as string) || '';
    if (search.length < 2) {
      return res.json([]);
    }

    const contribuyenteId = req.query.contribuyenteId as string | undefined;
    const emisores = await cfdiService.getEmisores(req.tenantPool, search, 10, contribuyenteId);
    res.json(emisores);
  } catch (error) {
    next(error);
  }
}

export async function getReceptores(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    const search = (req.query.search as string) || '';
    if (search.length < 2) {
      return res.json([]);
    }

    const contribuyenteId = req.query.contribuyenteId as string | undefined;
    const receptores = await cfdiService.getReceptores(req.tenantPool, search, 10, contribuyenteId);
    res.json(receptores);
  } catch (error) {
    next(error);
  }
}

export async function getResumen(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    const año = parseInt(req.query.año as string) || new Date().getFullYear();
    const mes = parseInt(req.query.mes as string) || new Date().getMonth() + 1;
    const contribuyenteId = req.query.contribuyenteId as string | undefined;

    const resumen = await cfdiService.getResumenCfdis(req.tenantPool, año, mes, contribuyenteId);
    res.json(resumen);
  } catch (error) {
    next(error);
  }
}

export async function createCfdi(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    if (!['owner', 'contador'].includes(req.user!.role)) {
      return next(new AppError(403, 'No tienes permisos para agregar CFDIs'));
    }

    const cfdi = await cfdiService.createCfdi(req.tenantPool, req.body);
    res.status(201).json(cfdi);
  } catch (error: any) {
    if (error.message?.includes('duplicate')) {
      return next(new AppError(409, 'Este CFDI ya existe (UUID duplicado)'));
    }
    next(error);
  }
}

export async function createManyCfdis(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    if (!['owner', 'contador'].includes(req.user!.role)) {
      return next(new AppError(403, 'No tienes permisos para agregar CFDIs'));
    }

    if (!Array.isArray(req.body.cfdis)) {
      return next(new AppError(400, 'Se requiere un array de CFDIs'));
    }

    const batchInfo = {
      batchNumber: req.body.batchNumber || 1,
      totalBatches: req.body.totalBatches || 1,
      totalFiles: req.body.totalFiles || req.body.cfdis.length
    };

    console.log(`[CFDI Bulk] Lote ${batchInfo.batchNumber}/${batchInfo.totalBatches} - ${req.body.cfdis.length} CFDIs`);

    const result = await cfdiService.createManyCfdisBatch(req.tenantPool, req.body.cfdis);

    res.status(201).json({
      message: `Lote ${batchInfo.batchNumber} procesado`,
      batchNumber: batchInfo.batchNumber,
      totalBatches: batchInfo.totalBatches,
      inserted: result.inserted,
      duplicates: result.duplicates,
      errors: result.errors,
      errorMessages: result.errorMessages.slice(0, 5)
    });
  } catch (error: any) {
    console.error('[CFDI Bulk Error]', error.message, error.stack);
    next(new AppError(400, error.message || 'Error al procesar CFDIs'));
  }
}

export async function deleteCfdi(req: Request, res: Response, next: NextFunction) {
  try {
    if (!req.tenantPool) {
      return next(new AppError(400, 'Tenant no configurado'));
    }

    if (!['owner', 'contador'].includes(req.user!.role)) {
      return next(new AppError(403, 'No tienes permisos para eliminar CFDIs'));
    }

    await cfdiService.deleteCfdi(req.tenantPool, String(req.params.id));
    res.status(204).send();
  } catch (error) {
    next(error);
  }
}