const express = require('express');
const jwt = require('jsonwebtoken');
const renderPage = require('../utils/renderHelper');
const advaloService = require('../services/advaloService');
const logger = require('../utils/logger');

const router = express.Router();

function getActor(req) {
  const authHeader = req.headers.authorization || '';
  const token = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : null;
  if (!token) {
    const err = new Error('Session invalide, reconnectez-vous.');
    err.status = 401;
    throw err;
  }
  return jwt.verify(token, 'no-mdp');
}

function handleError(res, error) {
  logger.log('error', `Advalo error: ${error.message}`, {
    status: error.status || 500,
    stack: error.stack,
    data: error.data,
    originalError: error.originalError ? String(error.originalError) : undefined
  });
  return res.status(error.status || 500).json({
    valid: false,
    message: error.message || 'Erreur serveur Advalorem'
  });
}

router.get('/', (_req, res) => {
  renderPage('advalo.ejs', res);
});

router.get('/lookup-contract', async (req, res) => {
  try {
    const actor = getActor(req);
    const info = await advaloService.lookupContract(req.query.numContrat, actor);
    return res.json({ valid: true, info });
  } catch (error) {
    return handleError(res, error);
  }
});

router.get('/historique', async (req, res) => {
  try {
    const actor = getActor(req);
    const data = await advaloService.getHistorique(req.query, actor);
    return res.json({
      valid: true,
      rows: data.rows,
      meta: {
        totalRows: data.totalRows,
        totalPages: data.totalPages,
        page: data.page,
        pageSize: data.pageSize
      }
    });
  } catch (error) {
    return handleError(res, error);
  }
});

router.get('/historique/:id', async (req, res) => {
  try {
    const actor = getActor(req);
    const data = await advaloService.getHistoriqueDetail(req.params.id, actor);
    return res.json({ valid: true, row: data });
  } catch (error) {
    return handleError(res, error);
  }
});

router.get('/cumul', async (req, res) => {
  try {
    const actor = getActor(req);
    const cumul = await advaloService.getCumul(req.query, actor);
    return res.json({ valid: true, ...cumul });
  } catch (error) {
    return handleError(res, error);
  }
});

router.post('/ponctuel', async (req, res) => {
  try {
    const actor = getActor(req);
    const row = await advaloService.createPonctuel(req.body, actor);
    return res.status(201).json({ valid: true, row });
  } catch (error) {
    return handleError(res, error);
  }
});

router.delete('/demande/:id', async (req, res) => {
  try {
    const actor = getActor(req);
    const row = await advaloService.softDeleteDemande(req.params.id, actor);
    return res.json({ valid: true, row });
  } catch (error) {
    return handleError(res, error);
  }
});

router.post('/facturation/batch', async (req, res) => {
  try {
    const actor = getActor(req);
    const result = await advaloService.facturerBatch(req.body, actor);
    return res.json({ valid: true, ...result });
  } catch (error) {
    return handleError(res, error);
  }
});

router.post('/demande/:id/avenant', async (req, res) => {
  try {
    const actor = getActor(req);
    const doc = await advaloService.generateDemandeDocument(req.params.id, 'avenant', actor);
    res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
    res.setHeader('Content-Disposition', `attachment; filename="${doc.filename}"`);
    return res.send(doc.buffer);
  } catch (error) {
    return handleError(res, error);
  }
});

router.post('/demande/:id/attestation', async (req, res) => {
  try {
    const actor = getActor(req);
    const doc = await advaloService.generateDemandeDocument(req.params.id, 'attestation', actor);
    res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
    res.setHeader('Content-Disposition', `attachment; filename="${doc.filename}"`);
    return res.send(doc.buffer);
  } catch (error) {
    return handleError(res, error);
  }
});

router.post('/facturation/batch/:id/avenant', async (req, res) => {
  try {
    const actor = getActor(req);
    const doc = await advaloService.generateBatchAvenant(req.params.id, actor);
    res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
    res.setHeader('Content-Disposition', `attachment; filename="${doc.filename}"`);
    return res.send(doc.buffer);
  } catch (error) {
    return handleError(res, error);
  }
});

router.get('/reporting', async (req, res) => {
  try {
    const actor = getActor(req);
    const data = await advaloService.getReporting(req.query, actor);
    return res.json({ valid: true, ...data });
  } catch (error) {
    return handleError(res, error);
  }
});

router.get('/export', async (req, res) => {
  try {
    const actor = getActor(req);
    const csv = await advaloService.exportHistorique(req.query, actor);
    res.setHeader('Content-Type', 'text/csv; charset=utf-8');
    res.setHeader('Content-Disposition', 'attachment; filename="advalo_export.csv"');
    return res.send(csv);
  } catch (error) {
    return handleError(res, error);
  }
});

module.exports = router;