import { existsSync } from 'fs';

import { Injectable, InternalServerErrorException, Logger } from '@nestjs/common';

const MIN_VALID_PDF_BYTES = 2_000;

const PDF_PRINT_STYLES = `
<style id="contract-pdf-print-fix">
  @media print {
    html, body {
      background: #fff !important;
      -webkit-print-color-adjust: exact;
      print-color-adjust: exact;
    }
    .cover {
      min-height: auto !important;
      page-break-after: always;
    }
    .cover-title {
      margin: 24mm 0 20mm !important;
    }
  }
</style>`;

@Injectable()
export class ContractPdfService {
  private readonly logger = new Logger(ContractPdfService.name);

  async htmlToPdfBuffer(html: string): Promise<Buffer> {
    const preparedHtml = this.injectPdfPrintStyles(html);
    const executablePath = this.resolveExecutablePath();

    try {
      const puppeteer = await import('puppeteer');
      const launchOptions: import('puppeteer').LaunchOptions = {
        headless: true,
        args: [
          '--no-sandbox',
          '--disable-setuid-sandbox',
          '--disable-dev-shm-usage',
        ],
        ...(executablePath ? { executablePath } : {}),
      };

      const browser = await puppeteer.default.launch(launchOptions);
      try {
        const page = await browser.newPage();
        await page.setViewport({ width: 794, height: 1123, deviceScaleFactor: 1 });
        await page.setContent(preparedHtml, {
          waitUntil: 'load',
          timeout: 60_000,
        });
        await page.emulateMediaType('print');
        await new Promise((resolve) => setTimeout(resolve, 400));

        const pdf = await page.pdf({
          format: 'A4',
          printBackground: true,
          displayHeaderFooter: true,
          headerTemplate: '<span></span>',
          footerTemplate:
            '<div style="width:100%;font-size:8px;color:#64748b;text-align:center;font-family:Arial,sans-serif;">Page <span class="pageNumber"></span> of <span class="totalPages"></span></div>',
          margin: { top: '18mm', bottom: '22mm', left: '14mm', right: '14mm' },
        });

        const buffer = Buffer.from(pdf);
        if (!this.isValidPdf(buffer)) {
          throw new Error(
            `Puppeteer produced invalid PDF (${buffer.length} bytes)`,
          );
        }
        this.logger.log(
          `Contract PDF rendered (${buffer.length} bytes) via ${executablePath ?? 'bundled Chromium'}`,
        );
        return buffer;
      } finally {
        await browser.close();
      }
    } catch (err) {
      this.logger.error(
        `Puppeteer PDF failed (executable=${executablePath ?? 'default'}): ${err}`,
      );
      throw new InternalServerErrorException(
        'Contract PDF could not be generated. Ensure Chromium is installed or set PUPPETEER_EXECUTABLE_PATH.',
      );
    }
  }

  private injectPdfPrintStyles(html: string): string {
    if (html.includes('contract-pdf-print-fix')) return html;
    if (html.includes('</head>')) {
      return html.replace('</head>', `${PDF_PRINT_STYLES}</head>`);
    }
    return `${PDF_PRINT_STYLES}${html}`;
  }

  private resolveExecutablePath(): string | undefined {
    const fromEnv = process.env.PUPPETEER_EXECUTABLE_PATH?.trim();
    if (fromEnv && existsSync(fromEnv)) return fromEnv;

    const candidates = [
      '/usr/bin/chromium',
      '/usr/bin/chromium-browser',
      '/usr/bin/google-chrome-stable',
      '/usr/bin/google-chrome',
    ];
    return candidates.find((p) => existsSync(p));
  }

  private isValidPdf(buffer: Buffer): boolean {
    return (
      buffer.length >= MIN_VALID_PDF_BYTES &&
      buffer.subarray(0, 5).toString('ascii') === '%PDF-'
    );
  }
}
