import { Router } from 'express';
import multer from 'multer';
import xlsx from 'xlsx';
import path from 'node:path';
import fs from 'node:fs';
import db from '../db/index.js';
import { HttpError } from '../middleware/errorHandler.js';
import { requireInvestisseur } from '../middleware/investisseurScope.js';
import { generateSimul, generateSimulWithReinvestissements } from '../utils/schedule.js';

const router = Router();

const UPLOAD_DIR = process.env.UPLOAD_DIR || path.resolve('./uploads');
fs.mkdirSync(UPLOAD_DIR, { recursive: true });

const upload = multer({
  dest: UPLOAD_DIR,
  limits: { fileSize: 10 * 1024 * 1024 }, // 10 MB
});

/**
 * Step 1: POST /api/imports/preview
 *   multipart/form-data with `file` (xlsx/csv)
 *   -> returns: { headers: [...], sampleRows: [...], allRowCount, tempId }
 *
 * Step 2: POST /api/imports/apply
 *   body: { tempId, module, mapping, defaults }
 *   -> applies the mapping and inserts rows in the chosen module
 */

// Modules scoped to a specific investisseur (require X-Investisseur-Id)
const INVESTISSEUR_SCOPED = ['depots_retraits', 'investissements', 'remboursements'];

const MODULES = {
  depots_retraits: {
    requiredTargets: ['plateforme_id', 'date_operation', 'type', 'montant'],
    optionalTargets: ['libelle', 'reference', 'notes'],
  },
  investissements: {
    requiredTargets: ['plateforme_id', 'nom_projet', 'date_souscription', 'montant_investi'],
    optionalTargets: ['emetteur','date_premiere_echeance','date_cible','taux_interet','duree_mois','type_remb','freq_interets','statut','reference','notes'],
  },
  remboursements: {
    requiredTargets: ['investissement_id', 'date_remb'],
    optionalTargets: ['capital','cashback','interets_bruts','prelev_sociaux','prelev_forfaitaire','statut','notes'],
  },
  plateformes: {
    requiredTargets: ['nom'],
    optionalTargets: ['url', 'notes'],
  },
  taux_pfu: {
    requiredTargets: ['annee', 'pfu_total', 'impot_revenu', 'prelev_sociaux'],
    optionalTargets: [],
  },
};

/** Parse un fichier uploadé selon son extension → tableau d'objets */
function parseFile(filePath, originalName) {
  const ext = path.extname(originalName).toLowerCase();
  if (ext === '.json') {
    const content = fs.readFileSync(filePath, 'utf8');
    let parsed;
    try { parsed = JSON.parse(content); } catch {
      throw new HttpError(400, 'Fichier JSON invalide — vérifiez la syntaxe');
    }
    if (!Array.isArray(parsed)) {
      throw new HttpError(400, 'Le fichier JSON doit contenir un tableau d\'objets à la racine');
    }
    return { rows: parsed, sheetName: 'json' };
  }
  // Excel / CSV
  const wb = xlsx.readFile(filePath, { cellDates: true });
  const sheetName = wb.SheetNames[0];
  const ws = wb.Sheets[sheetName];
  return { rows: xlsx.utils.sheet_to_json(ws, { defval: null, raw: false }), sheetName };
}

router.post('/preview', upload.single('file'), (req, res, next) => {
  try {
    if (!req.file) throw new HttpError(400, 'No file uploaded');
    const { rows, sheetName } = parseFile(req.file.path, req.file.originalname);
    const headers = rows.length ? Object.keys(rows[0]) : [];

    res.json({
      tempId: path.basename(req.file.path),
      filename: req.file.originalname,
      sheetName,
      headers,
      sampleRows: rows.slice(0, 10),
      allRowCount: rows.length,
    });
  } catch (e) { next(e); }
});

router.post('/apply', (req, res, next) => {
  try {
    const { tempId, module, mapping, defaults = {} } = req.body || {};
    if (!tempId || !module || !mapping) {
      throw new HttpError(400, 'tempId, module and mapping are required');
    }
    const def = MODULES[module];
    if (!def) throw new HttpError(400, 'Unknown module');

    // Require a specific investisseur for transactional modules
    if (INVESTISSEUR_SCOPED.includes(module)) {
      requireInvestisseur(req, res, () => {});
    }

    const tempPath = path.join(UPLOAD_DIR, tempId);
    if (!fs.existsSync(tempPath)) throw new HttpError(404, 'Uploaded file expired');

    for (const target of def.requiredTargets) {
      if (!mapping[target] && defaults[target] === undefined) {
        throw new HttpError(400, `Missing mapping for required field: ${target}`);
      }
    }

    // Déterminer la source selon l'extension du fichier original (passé en body optionnel)
    const origName  = req.body.originalFilename || '';
    const isJson    = path.extname(origName).toLowerCase() === '.json';
    const srcLabel  = isJson ? 'import_json' : 'import_excel';

    const { rows } = parseFile(tempPath, origName || 'file.xlsx');

    let inserted = 0, skipped = 0;
    const errors = [];

    const tx = db.transaction(() => {
      for (let idx = 0; idx < rows.length; idx++) {
        const row = rows[idx];
        try {
          const v = (target) => {
            const col = mapping[target];
            if (col && row[col] !== undefined && row[col] !== null && row[col] !== '') {
              return row[col];
            }
            return defaults[target];
          };

          if (module === 'depots_retraits') {
            db.prepare(`
              INSERT INTO depots_retraits
                (investisseur_id, plateforme_id, date_operation, type, montant, libelle, reference, source)
              VALUES (?,?,?,?,?,?,?,?)
            `).run(
              req.investisseur.id,
              Number(v('plateforme_id')),
              normaliseDate(v('date_operation')),
              normaliseType(v('type')),
              num(v('montant')),
              v('libelle') || null,
              v('reference') || null,
              srcLabel,
            );

          } else if (module === 'investissements') {
            db.prepare(`
              INSERT INTO investissements
                (investisseur_id, plateforme_id, nom_projet, emetteur, date_souscription,
                 date_premiere_echeance, date_cible, montant_investi, taux_interet, duree_mois,
                 type_remb, freq_interets, statut, reference, source)
              VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
            `).run(
              req.investisseur.id,
              Number(v('plateforme_id')),
              String(v('nom_projet')),
              v('emetteur') || null,
              normaliseDate(v('date_souscription')),
              v('date_premiere_echeance') ? normaliseDate(v('date_premiere_echeance')) : null,
              v('date_cible') ? normaliseDate(v('date_cible')) : null,
              num(v('montant_investi')),
              v('taux_interet') ? Number(String(v('taux_interet')).replace(',', '.')) : null,
              v('duree_mois') ? parseInt(v('duree_mois'), 10) : null,
              v('type_remb') || null,
              v('freq_interets') || 'mensuel',
              v('statut') || 'en_cours',
              v('reference') || null,
              srcLabel,
            );

          } else if (module === 'remboursements') {
            const capital     = num(v('capital'));
            const cashback    = num(v('cashback'));
            const bruts       = num(v('interets_bruts'));
            const ps          = num(v('prelev_sociaux'));
            const pf          = num(v('prelev_forfaitaire'));
            const interets_nets = Math.round((bruts - ps - pf) * 100) / 100;
            const net_recu      = Math.round((capital + cashback + interets_nets) * 100) / 100;
            db.prepare(`
              INSERT INTO remboursements
                (investissement_id, date_remb, capital, cashback, interets_bruts, prelev_sociaux,
                 prelev_forfaitaire, interets_nets, net_recu, statut, source)
              VALUES (?,?,?,?,?,?,?,?,?,?,?)
            `).run(
              Number(v('investissement_id')),
              normaliseDate(v('date_remb')),
              capital, cashback, bruts, ps, pf, interets_nets, net_recu,
              v('statut') || 'paye',
              srcLabel,
            );

          } else if (module === 'plateformes') {
            const nom = String(v('nom') || '').trim();
            if (!nom) throw new Error('Le champ nom est vide');
            const r = db.prepare(`
              INSERT OR IGNORE INTO plateformes (user_id, nom, url, notes)
              VALUES (?, ?, ?, ?)
            `).run(
              req.user.id,
              nom,
              v('url') || null,
              v('notes') || null,
            );
            // changes = 0 means the row was ignored (nom already exists)
            if (r.changes === 0) throw new Error(`Plateforme "${nom}" existe déjà — ignorée`);

          } else if (module === 'taux_pfu') {
            const annee = parseInt(v('annee'), 10);
            if (!annee || annee < 2000 || annee > 2100) throw new Error('Année invalide');
            db.prepare(`
              INSERT INTO taux_pfu (annee, pfu_total, impot_revenu, prelev_sociaux)
              VALUES (?, ?, ?, ?)
              ON CONFLICT(annee) DO UPDATE SET
                pfu_total      = excluded.pfu_total,
                impot_revenu   = excluded.impot_revenu,
                prelev_sociaux = excluded.prelev_sociaux,
                updated_at     = datetime('now')
            `).run(
              annee,
              num(v('pfu_total')),
              num(v('impot_revenu')),
              num(v('prelev_sociaux')),
            );
          }

          inserted++;
        } catch (err) {
          skipped++;
          errors.push({ row: idx + 2, error: err.message });
        }
      }
    });
    tx();

    db.prepare(`
      INSERT INTO imports (user_id, investisseur_id, module, filename, rows_total, rows_inserted, rows_skipped, mapping_json)
      VALUES (?,?,?,?,?,?,?,?)
    `).run(
      req.user.id,
      req.investisseur?.id ?? null,
      module,
      tempId,
      rows.length,
      inserted,
      skipped,
      JSON.stringify(mapping),
    );

    // Clean up temp file
    try { fs.unlinkSync(tempPath); } catch { /* */ }

    res.json({ inserted, skipped, total: rows.length, errors: errors.slice(0, 50) });
  } catch (e) { next(e); }
});

/**
 * POST /api/imports/dossier
 * Importe un dossier investissement complet (format d'export natif).
 * Scénario CREATE : le dossier n'existe pas → création complète.
 * Scénario UPDATE : le dossier existe déjà → mise à jour des champs + remboursements manquants.
 * Identification : (investisseur_id, nom_projet, date_souscription) — clé naturelle portable.
 */
router.post('/dossier', (req, res, next) => {
  try {
    requireInvestisseur(req, res, () => {});

    const { dossier } = req.body || {};
    if (!dossier || dossier.type !== 'dossier_investissement') {
      throw new HttpError(400, 'Format invalide — attendu { dossier: { type: "dossier_investissement", ... } }');
    }
    const { investissement: inv, plateforme: platInfo, remboursements = [], reinvestissements = [], historique = [] } = dossier;
    if (!inv?.nom_projet || !inv?.date_souscription) {
      throw new HttpError(400, 'Champs obligatoires manquants : nom_projet, date_souscription');
    }

    let action, investissementId;

    const tx = db.transaction(() => {
      /* ── 1. Résoudre / créer la plateforme ─────────────────── */
      let platRow = db.prepare('SELECT id FROM plateformes WHERE user_id = ? AND nom = ?')
        .get(req.user.id, platInfo?.nom || '');
      if (!platRow && platInfo?.nom) {
        const r = db.prepare('INSERT INTO plateformes (user_id, nom, url) VALUES (?,?,?)')
          .run(req.user.id, platInfo.nom, platInfo.url || null);
        platRow = { id: r.lastInsertRowid };
      }
      if (!platRow) throw new HttpError(400, 'Plateforme introuvable et nom manquant dans le dossier');
      const plateformeId = platRow.id;

      /* ── 2. Chercher l'investissement existant (clé naturelle) */
      const existing = db.prepare(`
        SELECT id FROM investissements
        WHERE investisseur_id = ? AND nom_projet = ? AND date_souscription = ?
        LIMIT 1
      `).get(req.investisseur.id, inv.nom_projet, inv.date_souscription);

      if (!existing) {
        /* ────────────── SCÉNARIO CREATE ──────────────────────── */
        const r = db.prepare(`
          INSERT INTO investissements
            (investisseur_id, plateforme_id, nom_projet, emetteur, date_souscription,
             date_premiere_echeance, date_cible, date_debut_simul, montant_investi,
             taux_interet, duree_mois, type_remb, freq_interets, statut, reference, source, notes)
          VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?, 'import_dossier', ?)
        `).run(
          req.investisseur.id, plateformeId,
          inv.nom_projet, inv.emetteur || null,
          inv.date_souscription,
          inv.date_premiere_echeance || null, inv.date_cible || null, inv.date_debut_simul || null,
          Number(inv.montant_investi), inv.taux_interet ?? null, inv.duree_mois ?? null,
          inv.type_remb || 'in_fine', inv.freq_interets || 'mensuel',
          inv.statut || 'en_cours', inv.reference || null, inv.notes || null,
        );
        investissementId = Number(r.lastInsertRowid);

        // Remboursements
        for (const rb of remboursements) {
          db.prepare(`
            INSERT INTO remboursements
              (investissement_id, date_remb, capital, cashback, interets_bruts,
               prelev_sociaux, prelev_forfaitaire, interets_nets, net_recu, statut, notes, source)
            VALUES (?,?,?,?,?,?,?,?,?,?,?, 'import_dossier')
          `).run(
            investissementId, rb.date_remb,
            rb.capital || 0, rb.cashback || 0, rb.interets_bruts || 0,
            rb.prelev_sociaux || 0, rb.prelev_forfaitaire || 0,
            rb.interets_nets || 0, rb.net_recu || 0,
            rb.statut || 'paye', rb.notes || null,
          );
        }

        // Réinvestissements
        for (const rv of reinvestissements) {
          if (!rv.date_reinvestissement || !rv.montant) continue;
          db.prepare(`
            INSERT INTO reinvestissements (investissement_id, montant, date_reinvestissement, note, source)
            VALUES (?, ?, ?, ?, ?)
          `).run(
            investissementId,
            Number(rv.montant),
            rv.date_reinvestissement,
            rv.note || null,
            rv.source || 'manuel',
          );
        }

        // Historique (lecture seule — on importe pour la traçabilité)
        for (const h of historique) {
          db.prepare(`
            INSERT INTO investissement_historique
              (investissement_id, type_evenement, changements, notes, created_at)
            VALUES (?,?,?,?,?)
          `).run(
            investissementId,
            h.type_evenement || 'import',
            typeof h.changements === 'string' ? h.changements : JSON.stringify(h.changements || []),
            h.notes || null,
            h.created_at || null,
          );
        }
        // Entrée d'historique de l'import lui-même
        db.prepare(`
          INSERT INTO investissement_historique (investissement_id, type_evenement, changements)
          VALUES (?, 'import', ?)
        `).run(investissementId, JSON.stringify([{
          champ: 'import', label: 'Import dossier',
          ancienne_valeur: null, nouvelle_valeur: dossier.exported_at || 'inconnu',
        }]));

        action = 'created';
      } else {
        /* ────────────── SCÉNARIO UPDATE ──────────────────────── */
        investissementId = existing.id;
        db.prepare(`
          UPDATE investissements SET
            plateforme_id = ?, emetteur = ?,
            date_premiere_echeance = ?, date_cible = ?, date_debut_simul = ?,
            montant_investi = ?, taux_interet = ?, duree_mois = ?,
            type_remb = ?, freq_interets = ?, statut = ?,
            reference = ?, notes = ?
          WHERE id = ?
        `).run(
          plateformeId, inv.emetteur || null,
          inv.date_premiere_echeance || null, inv.date_cible || null, inv.date_debut_simul || null,
          Number(inv.montant_investi), inv.taux_interet ?? null, inv.duree_mois ?? null,
          inv.type_remb || 'in_fine', inv.freq_interets || 'mensuel',
          inv.statut || 'en_cours',
          inv.reference || null, inv.notes || null,
          investissementId,
        );

        // Remboursements : ajouter les manquants (clé naturelle = date_remb + capital + interets_bruts)
        let rembInserted = 0;
        for (const rb of remboursements) {
          const exists = db.prepare(`
            SELECT id FROM remboursements
            WHERE investissement_id = ? AND date_remb = ?
              AND ABS(capital - ?) < 0.005 AND ABS(interets_bruts - ?) < 0.005
          `).get(investissementId, rb.date_remb, rb.capital || 0, rb.interets_bruts || 0);
          if (!exists) {
            db.prepare(`
              INSERT INTO remboursements
                (investissement_id, date_remb, capital, cashback, interets_bruts,
                 prelev_sociaux, prelev_forfaitaire, interets_nets, net_recu, statut, notes, source)
              VALUES (?,?,?,?,?,?,?,?,?,?,?, 'import_dossier')
            `).run(
              investissementId, rb.date_remb,
              rb.capital || 0, rb.cashback || 0, rb.interets_bruts || 0,
              rb.prelev_sociaux || 0, rb.prelev_forfaitaire || 0,
              rb.interets_nets || 0, rb.net_recu || 0,
              rb.statut || 'paye', rb.notes || null,
            );
            rembInserted++;
          }
        }

        // Réinvestissements : ajouter les manquants (clé = date + montant)
        let reinvInserted = 0;
        for (const rv of reinvestissements) {
          if (!rv.date_reinvestissement || !rv.montant) continue;
          const rvExists = db.prepare(`
            SELECT id FROM reinvestissements
            WHERE investissement_id = ? AND date_reinvestissement = ? AND ABS(montant - ?) < 0.005
          `).get(investissementId, rv.date_reinvestissement, Number(rv.montant));
          if (!rvExists) {
            db.prepare(`
              INSERT INTO reinvestissements (investissement_id, montant, date_reinvestissement, note, source)
              VALUES (?, ?, ?, ?, ?)
            `).run(
              investissementId,
              Number(rv.montant),
              rv.date_reinvestissement,
              rv.note || null,
              rv.source || 'manuel',
            );
            reinvInserted++;
          }
        }

        // Entrée d'historique de la mise à jour
        db.prepare(`
          INSERT INTO investissement_historique (investissement_id, type_evenement, changements)
          VALUES (?, 'import', ?)
        `).run(investissementId, JSON.stringify([{
          champ: 'import', label: 'Mise à jour dossier',
          ancienne_valeur: null,
          nouvelle_valeur: `${dossier.exported_at || 'inconnu'} — ${rembInserted} remb. ajouté(s), ${reinvInserted} réinvest. ajouté(s)`,
        }]));

        action = 'updated';
      }
    });
    tx();

    /* ── 3. Régénérer la simulation ─────────────────────────── */
    const fresh = db.prepare('SELECT * FROM investissements WHERE id = ?').get(investissementId);
    generateSimulWithReinvestissements(db, investissementId);

    /* ── 4. Log import ──────────────────────────────────────── */
    db.prepare(`
      INSERT INTO imports (user_id, investisseur_id, module, filename, rows_total, rows_inserted, rows_skipped, mapping_json)
      VALUES (?,?,?,?,?,?,?,?)
    `).run(
      req.user.id, req.investisseur.id,
      'dossier_investissement',
      `Dossier_${inv.nom_projet}`,
      1, 1, 0,
      JSON.stringify({ action, investissementId }),
    );

    res.json({ action, investissementId });
  } catch (e) { next(e); }
});

router.get('/history', (req, res) => {
  const rows = db.prepare(`
    SELECT * FROM imports WHERE user_id=? ORDER BY id DESC LIMIT 100
  `).all(req.user.id);
  res.json(rows);
});

// helpers

/** Supprime les accents/diacritiques d'une chaîne (ex. "Dépôt" → "Depot") */
function stripAccents(s) {
  return String(s).normalize('NFD').replace(/[̀-ͯ]/g, '');
}

/** Convertit une valeur monétaire en nombre (gère "€", espaces, virgule décimale) */
function num(v) {
  if (v === undefined || v === null || v === '') return 0;
  // Supprimer tout ce qui n'est pas chiffre, virgule, point ou signe moins
  const clean = String(v).replace(/[^\d,.-]/g, '').replace(',', '.');
  const n = Number(clean);
  return isNaN(n) ? 0 : n;
}

function normaliseType(v) {
  // Normalise les accents avant la comparaison : "Dépôt" → "depot"
  const s = stripAccents(String(v || '')).toLowerCase();
  if (s.startsWith('dep') || s === 'versement' || s === 'in') return 'depot';
  if (s.startsWith('ret') || s === 'withdrawal' || s === 'out') return 'retrait';
  return s; // CHECK constraint will reject if invalid
}
function normaliseDate(v) {
  if (!v) return null;
  if (v instanceof Date) return v.toISOString().slice(0, 10);
  const s = String(v).trim();
  // Already ISO
  if (/^\d{4}-\d{2}-\d{2}/.test(s)) return s.slice(0, 10);
  // dd/mm/yyyy
  const m = s.match(/^(\d{1,2})[/.-](\d{1,2})[/.-](\d{2,4})$/);
  if (m) {
    const [_, d, mo, y] = m;
    const yy = y.length === 2 ? '20' + y : y;
    return `${yy}-${mo.padStart(2, '0')}-${d.padStart(2, '0')}`;
  }
  return s;
}

export default router;