const express = require('express');
const multer = require('multer');
const path = require('path');
const fs = require('fs');
const { spawn } = require('child_process');
const rateLimit = require('express-rate-limit');
const archiver = require('archiver');
const log = require('../lib/logger');
const { UPLOADS_DIR, RESULTS_DIR } = require('../lib/storage');

const router = express.Router();

const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB

const upload = multer({
  dest: UPLOADS_DIR,
  limits: { fileSize: MAX_FILE_SIZE },
  fileFilter: (req, file, cb) => {
    if (file.mimetype === 'application/pdf' || file.originalname.endsWith('.pdf')) cb(null, true);
    else if (file.mimetype.startsWith('image/')) cb(null, true); // for fromImages
    else cb(new Error('Только PDF и изображения'));
  },
});

const limiter = rateLimit({
  keyGenerator: (req) => (req.session && req.session.user && req.session.user.id) ? "user_" + req.session.user.id : req.ip, windowMs: 60000, max: 30, message: { error: 'Слишком много запросов' } });

// Rate-limit ALL pdf routes (several spawn Ghostscript / do heavy pdf-lib work)
router.use(limiter);

// Fix multer filename encoding (Latin-1 → UTF-8 for Cyrillic)
function fixFilename(str) {
  try {
    const buf = Buffer.from(str, 'latin1');
    const decoded = buf.toString('utf8');
    if (/[а-яёА-ЯЁ]/.test(decoded)) return decoded;
  } catch {}
  return str;
}

// File storage for uploaded PDFs
const pdfFiles = new Map();

function registerFile(multerFile, pageCount) {
  const id = `pdf_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
  const entry = {
    id,
    path: multerFile.path,
    name: fixFilename(multerFile.originalname),
    size: multerFile.size,
    pages: pageCount || 0,
  };
  pdfFiles.set(id, entry);
  setTimeout(() => {
    try { fs.existsSync(entry.path) && fs.unlinkSync(entry.path); } catch {}
    pdfFiles.delete(id);
  }, 30 * 60 * 1000);
  return entry;
}

function getFile(id) {
  const f = pdfFiles.get(id);
  if (!f || !fs.existsSync(f.path)) return null;
  return f;
}

function saveResult(buffer, ext) {
  const name = `result_${Date.now()}_${Math.random().toString(36).slice(2, 6)}${ext}`;
  const outPath = path.join(RESULTS_DIR, name);
  fs.writeFileSync(outPath, buffer);
  setTimeout(() => { try { fs.unlinkSync(outPath); } catch {} }, 30 * 60 * 1000);
  return `/pdf/download/${name}`;
}

// Page
router.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, '..', 'public', 'pdf.html'));
});

// Upload
router.post('/upload', upload.array('files', 10), async (req, res) => {
  if (!req.files || !req.files.length) return res.status(400).json({ error: 'Файлы не загружены' });

  const results = [];

  for (const file of req.files) {
    let pages = 0;
    try {
      if (file.mimetype === 'application/pdf' || file.originalname.endsWith('.pdf')) {
        const buf = fs.readFileSync(file.path);
        // Use pdf-lib for page count (more reliable than pdf-parse)
        const { PDFDocument } = await import('pdf-lib');
        const doc = await PDFDocument.load(buf, { ignoreEncryption: true });
        pages = doc.getPageCount();
      }
    } catch (e) {
      log.warn('PDF page count failed', { file: file.originalname, error: e.message });
    }
    const entry = registerFile(file, pages);
    results.push({ id: entry.id, name: entry.name, size: entry.size, pages });
  }

  log.info(`PDF upload: ${results.length} files`);
  res.json({ files: results });
});

// Preview — render PDF page as PNG thumbnail via Ghostscript
router.get('/preview/:fileId', (req, res) => renderPreview(req, res, 1));
router.get('/preview/:fileId/:page', (req, res) => renderPreview(req, res, parseInt(req.params.page) || 1));

async function renderPreview(req, res, pageNum) {
  const f = getFile(req.params.fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  const cacheKey = `${f.id}_p${pageNum}`;
  const cachePath = path.join(RESULTS_DIR, `preview_${cacheKey}.png`);

  // Return cached if exists
  if (fs.existsSync(cachePath)) {
    return res.type('png').sendFile(cachePath);
  }

  try {
    await new Promise((resolve, reject) => {
      const proc = spawn('gs', [
        '-sDEVICE=png16m', '-r72', '-dNOPAUSE', '-dBATCH', '-dQUIET',
        `-dFirstPage=${pageNum}`, `-dLastPage=${pageNum}`,
        '-dTextAlphaBits=4', '-dGraphicsAlphaBits=4',
        `-sOutputFile=${cachePath}`, f.path,
      ], { timeout: 15000 });
      proc.on('close', code => code === 0 ? resolve() : reject(new Error('Preview failed')));
      proc.on('error', reject);
    });

    // Cleanup after 30 min
    setTimeout(() => { try { fs.unlinkSync(cachePath); } catch {} }, 30 * 60 * 1000);

    res.type('png').sendFile(cachePath);
  } catch (err) {
    res.status(500).json({ error: 'Не удалось создать превью' });
  }
}

// Thumbnails — return preview URLs for all pages
router.get('/thumbnails/:fileId', async (req, res) => {
  const f = getFile(req.params.fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  const urls = [];
  for (let i = 1; i <= Math.min(f.pages, 50); i++) {
    urls.push(`/pdf/preview/${f.id}/${i}`);
  }
  res.json({ pages: f.pages, thumbnails: urls });
});

// Info
router.get('/info/:fileId', async (req, res) => {
  const f = getFile(req.params.fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  try {
    const pdfParse = require('pdf-parse');
    const buf = fs.readFileSync(f.path);
    const data = await pdfParse(buf);
    res.json({
      pages: data.numpages,
      title: data.info?.Title || '',
      author: data.info?.Author || '',
      creator: data.info?.Creator || '',
      size: f.size,
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Merge
router.post('/merge', express.json(), async (req, res) => {
  const { fileIds } = req.body;
  if (!fileIds || fileIds.length < 2) return res.status(400).json({ error: 'Нужно минимум 2 файла' });

  try {
    const { PDFDocument } = await import('pdf-lib');
    const merged = await PDFDocument.create();

    for (const id of fileIds) {
      const f = getFile(id);
      if (!f) return res.status(404).json({ error: `Файл ${id} не найден` });
      const buf = fs.readFileSync(f.path);
      const doc = await PDFDocument.load(buf);
      const pages = await merged.copyPages(doc, doc.getPageIndices());
      pages.forEach(p => merged.addPage(p));
    }

    const result = await merged.save();
    const url = saveResult(Buffer.from(result), '.pdf');
    res.json({ downloadUrl: url, size: result.length });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Split
router.post('/split', express.json(), async (req, res) => {
  const { fileId, ranges } = req.body;
  const f = getFile(fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  try {
    const { PDFDocument } = await import('pdf-lib');
    const buf = fs.readFileSync(f.path);
    const srcDoc = await PDFDocument.load(buf);
    const totalPages = srcDoc.getPageCount();

    // Parse ranges: "1-3,5,7-9"
    const pageNums = [];
    for (const part of ranges.split(',')) {
      const trimmed = part.trim();
      if (trimmed.includes('-')) {
        const [start, end] = trimmed.split('-').map(Number);
        for (let i = start; i <= Math.min(end, totalPages); i++) pageNums.push(i);
      } else {
        const n = parseInt(trimmed);
        if (n >= 1 && n <= totalPages) pageNums.push(n);
      }
    }

    if (pageNums.length === 0) return res.status(400).json({ error: 'Нет валидных страниц' });

    // Single output PDF with selected pages
    const newDoc = await PDFDocument.create();
    const indices = pageNums.map(n => n - 1); // 0-based
    const copiedPages = await newDoc.copyPages(srcDoc, indices);
    copiedPages.forEach(p => newDoc.addPage(p));

    const result = await newDoc.save();
    const url = saveResult(Buffer.from(result), '.pdf');
    res.json({ downloadUrl: url, size: result.length, pages: pageNums.length });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Rotate
router.post('/rotate', express.json(), async (req, res) => {
  const { fileId, pages, angle } = req.body;
  const f = getFile(fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  try {
    const { PDFDocument, degrees } = await import('pdf-lib');
    const buf = fs.readFileSync(f.path);
    const doc = await PDFDocument.load(buf);
    const total = doc.getPageCount();

    const targetPages = pages === 'all'
      ? Array.from({ length: total }, (_, i) => i)
      : pages.split(',').map(n => parseInt(n.trim()) - 1).filter(i => i >= 0 && i < total);

    for (const idx of targetPages) {
      const page = doc.getPage(idx);
      const current = page.getRotation().angle;
      page.setRotation(degrees(current + (angle || 90)));
    }

    const result = await doc.save();
    const url = saveResult(Buffer.from(result), '.pdf');
    res.json({ downloadUrl: url, size: result.length });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Delete pages
router.post('/delete', express.json(), async (req, res) => {
  const { fileId, pages } = req.body;
  const f = getFile(fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  try {
    const { PDFDocument } = await import('pdf-lib');
    const buf = fs.readFileSync(f.path);
    const srcDoc = await PDFDocument.load(buf);
    const total = srcDoc.getPageCount();

    const deleteSet = new Set(pages.split(',').map(n => parseInt(n.trim()) - 1));
    const keepIndices = Array.from({ length: total }, (_, i) => i).filter(i => !deleteSet.has(i));

    if (keepIndices.length === 0) return res.status(400).json({ error: 'Нельзя удалить все страницы' });

    const newDoc = await PDFDocument.create();
    const copied = await newDoc.copyPages(srcDoc, keepIndices);
    copied.forEach(p => newDoc.addPage(p));

    const result = await newDoc.save();
    const url = saveResult(Buffer.from(result), '.pdf');
    res.json({ downloadUrl: url, size: result.length, pages: keepIndices.length });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Reorder
router.post('/reorder', express.json(), async (req, res) => {
  const { fileId, order } = req.body;
  const f = getFile(fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  try {
    const { PDFDocument } = await import('pdf-lib');
    const buf = fs.readFileSync(f.path);
    const srcDoc = await PDFDocument.load(buf);
    const indices = order.map(n => n - 1); // 1-based to 0-based

    const newDoc = await PDFDocument.create();
    const copied = await newDoc.copyPages(srcDoc, indices);
    copied.forEach(p => newDoc.addPage(p));

    const result = await newDoc.save();
    const url = saveResult(Buffer.from(result), '.pdf');
    res.json({ downloadUrl: url, size: result.length });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Watermark
router.post('/watermark', express.json(), async (req, res) => {
  const { fileId, text, fontSize = 48, opacity = 0.3, color = '#888888' } = req.body;
  const f = getFile(fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  try {
    const { PDFDocument, rgb, StandardFonts } = await import('pdf-lib');
    const buf = fs.readFileSync(f.path);
    const doc = await PDFDocument.load(buf);
    const font = await doc.embedFont(StandardFonts.Helvetica);

    const r = parseInt(color.slice(1, 3), 16) / 255;
    const g = parseInt(color.slice(3, 5), 16) / 255;
    const b = parseInt(color.slice(5, 7), 16) / 255;

    for (let i = 0; i < doc.getPageCount(); i++) {
      const page = doc.getPage(i);
      const { width, height } = page.getSize();
      const textWidth = font.widthOfTextAtSize(text, fontSize);

      page.drawText(text, {
        x: (width - textWidth) / 2,
        y: height / 2,
        size: fontSize,
        font,
        color: rgb(r, g, b),
        opacity,
        rotate: { type: 'degrees', angle: -45 },
      });
    }

    const result = await doc.save();
    const url = saveResult(Buffer.from(result), '.pdf');
    res.json({ downloadUrl: url, size: result.length });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Page numbers
router.post('/pagenumbers', express.json(), async (req, res) => {
  const { fileId, position = 'bottom-center', startFrom = 1 } = req.body;
  const f = getFile(fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  try {
    const { PDFDocument, rgb, StandardFonts } = await import('pdf-lib');
    const buf = fs.readFileSync(f.path);
    const doc = await PDFDocument.load(buf);
    const font = await doc.embedFont(StandardFonts.Helvetica);
    const total = doc.getPageCount();

    for (let i = 0; i < total; i++) {
      const page = doc.getPage(i);
      const { width } = page.getSize();
      const numText = String(i + startFrom);
      const textWidth = font.widthOfTextAtSize(numText, 10);

      let x = (width - textWidth) / 2; // center
      let y = 30;

      if (position.includes('left')) x = 40;
      if (position.includes('right')) x = width - 40 - textWidth;
      if (position.includes('top')) y = page.getSize().height - 30;

      page.drawText(numText, { x, y, size: 10, font, color: rgb(0.4, 0.4, 0.4) });
    }

    const result = await doc.save();
    const url = saveResult(Buffer.from(result), '.pdf');
    res.json({ downloadUrl: url, size: result.length });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Compress (Ghostscript)
router.post('/compress', express.json(), async (req, res) => {
  const { fileId, quality = 'ebook' } = req.body;
  const f = getFile(fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  const outName = `compressed_${Date.now()}.pdf`;
  const outPath = path.join(RESULTS_DIR, outName);
  const settings = { screen: '/screen', ebook: '/ebook', printer: '/printer' };

  try {
    await new Promise((resolve, reject) => {
      const proc = spawn('gs', [
        '-sDEVICE=pdfwrite', '-dCompatibilityLevel=1.4',
        `-dPDFSETTINGS=${settings[quality] || '/ebook'}`,
        '-dNOPAUSE', '-dBATCH', '-dQUIET',
        `-sOutputFile=${outPath}`, f.path,
      ], { timeout: 120000 });
      proc.on('close', code => code === 0 ? resolve() : reject(new Error('Ghostscript error')));
      proc.on('error', reject);
    });

    const stat = fs.statSync(outPath);
    const savings = f.size > 0 ? Math.round((1 - stat.size / f.size) * 100) : 0;
    setTimeout(() => { try { fs.unlinkSync(outPath); } catch {} }, 30 * 60 * 1000);

    res.json({ downloadUrl: `/pdf/download/${outName}`, size: stat.size, savings });
  } catch (err) {
    try { fs.unlinkSync(outPath); } catch {}
    res.status(500).json({ error: err.message });
  }
});

// Protect (add password)
router.post('/protect', express.json(), async (req, res) => {
  const { fileId, password } = req.body;
  const f = getFile(fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });
  if (!password) return res.status(400).json({ error: 'Пароль обязателен' });

  try {
    const { PDFDocument } = await import('pdf-lib');
    const buf = fs.readFileSync(f.path);
    const doc = await PDFDocument.load(buf);
    doc.encrypt({ userPassword: password, ownerPassword: password });

    const result = await doc.save();
    const url = saveResult(Buffer.from(result), '.pdf');
    res.json({ downloadUrl: url, size: result.length });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Extract text
router.post('/extract-text', express.json(), async (req, res) => {
  const { fileId } = req.body;
  const f = getFile(fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  try {
    const pdfParse = require('pdf-parse');
    const buf = fs.readFileSync(f.path);
    const data = await pdfParse(buf);
    res.json({
      text: data.text,
      pages: data.numpages,
      metadata: data.info || {},
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// PDF to Images (Ghostscript)
router.post('/toImages', express.json(), async (req, res) => {
  const { fileId, format = 'png' } = req.body;
  // Clamp DPI to avoid Ghostscript rendering gigantic bitmaps (memory/disk DoS)
  const dpi = Math.min(300, Math.max(36, parseInt(req.body.dpi) || 150));
  const f = getFile(fileId);
  if (!f) return res.status(404).json({ error: 'Файл не найден' });

  const tmpDir = path.join(RESULTS_DIR, `img_${Date.now()}`);
  fs.mkdirSync(tmpDir, { recursive: true });
  const device = format === 'jpg' ? 'jpeg' : 'png16m';

  try {
    await new Promise((resolve, reject) => {
      const proc = spawn('gs', [
        `-sDEVICE=${device}`, `-r${dpi}`,
        '-dNOPAUSE', '-dBATCH', '-dQUIET',
        `-sOutputFile=${tmpDir}/page_%03d.${format === 'jpg' ? 'jpg' : 'png'}`,
        f.path,
      ], { timeout: 120000 });
      proc.on('close', code => code === 0 ? resolve() : reject(new Error('Ghostscript error')));
      proc.on('error', reject);
    });

    // ZIP the images
    const zipName = `pages_${Date.now()}.zip`;
    const zipPath = path.join(RESULTS_DIR, zipName);
    const output = fs.createWriteStream(zipPath);
    const archive = archiver('zip', { zlib: { level: 6 } });
    const zipDone = new Promise((resolve, reject) => { output.on('close', resolve); output.on('error', reject); archive.on('error', reject); });
    archive.pipe(output);
    archive.directory(tmpDir, false);
    await archive.finalize();
    await zipDone;

    // Cleanup temp dir
    fs.readdirSync(tmpDir).forEach(f => fs.unlinkSync(path.join(tmpDir, f)));
    fs.rmdirSync(tmpDir);

    setTimeout(() => { try { fs.unlinkSync(zipPath); } catch {} }, 30 * 60 * 1000);
    const stat = fs.statSync(zipPath);
    res.json({ downloadUrl: `/pdf/download/${zipName}`, size: stat.size });
  } catch (err) {
    try { fs.readdirSync(tmpDir).forEach(f => fs.unlinkSync(path.join(tmpDir, f))); fs.rmdirSync(tmpDir); } catch {}
    res.status(500).json({ error: err.message });
  }
});

// Images to PDF
router.post('/fromImages', upload.array('images', 50), async (req, res) => {
  if (!req.files || !req.files.length) return res.status(400).json({ error: 'Изображения не загружены' });

  try {
    const { PDFDocument } = await import('pdf-lib');
    const doc = await PDFDocument.create();

    for (const file of req.files) {
      const imgBytes = fs.readFileSync(file.path);
      let img;
      if (file.mimetype === 'image/png') img = await doc.embedPng(imgBytes);
      else img = await doc.embedJpg(imgBytes);

      const page = doc.addPage([img.width, img.height]);
      page.drawImage(img, { x: 0, y: 0, width: img.width, height: img.height });

      try { fs.unlinkSync(file.path); } catch {}
    }

    const result = await doc.save();
    const url = saveResult(Buffer.from(result), '.pdf');
    res.json({ downloadUrl: url, size: result.length, pages: req.files.length });
  } catch (err) {
    req.files.forEach(f => { try { fs.unlinkSync(f.path); } catch {} });
    res.status(500).json({ error: err.message });
  }
});

// Download
router.get('/download/:filename', (req, res) => {
  const filename = path.basename(req.params.filename);
  const filePath = path.join(RESULTS_DIR, filename);
  if (!fs.existsSync(filePath)) return res.status(404).json({ error: 'Файл не найден' });
  res.download(filePath);
});

// Multer error handler
router.use((err, req, res, next) => {
  if (err instanceof multer.MulterError) {
    if (err.code === 'LIMIT_FILE_SIZE') return res.status(413).json({ error: 'Файл слишком большой. Максимум 50MB.' });
    return res.status(400).json({ error: err.message });
  }
  if (err) return res.status(400).json({ error: err.message });
  next();
});

module.exports = router;