import puppeteer from 'puppeteer';
import { prisma } from '../prismaClient';
import { PDFDocument, rgb, StandardFonts } from 'pdf-lib';
import fs from 'fs/promises';
import path from 'path';

/**
 * Serviço para geração e manipulação de arquivos PDF
 */
export class PdfService {
  /**
   * Cria um documento PDF básico
   * @returns Documento PDF
   */
  async criarDocumento() {
    return await PDFDocument.create();
  }
  
  /**
   * Carrega um documento PDF existente
   * @param pdfBytes - Bytes do PDF
   * @returns Documento PDF
   */
  async carregarDocumento(pdfBytes: Uint8Array) {
    return await PDFDocument.load(pdfBytes);
  }
  
  /**
   * Adiciona uma página ao documento
   * @param doc - Documento PDF
   * @param tamanho - Tamanho da página (padrão: A4)
   * @returns Página adicionada
   */
  adicionarPagina(doc: any, tamanho = [595.28, 841.89]) {
    return doc.addPage(tamanho);
  }
  
  /**
   * Salva o documento como buffer
   * @param doc - Documento PDF
   * @returns Buffer do PDF
   */
  async salvarComoBuffer(doc: any): Promise<Buffer> {
    const pdfBytes = await doc.save();
    return Buffer.from(pdfBytes);
  }
  
  /**
   * Carrega uma fonte padrão
   * @param doc - Documento PDF
   * @param fonte - Nome da fonte padrão
   * @returns Fonte carregada
   */
  async carregarFonte(doc: any, fonte: StandardFonts) {
    return await doc.embedFont(fonte);
  }
  
  /**
   * Desenha texto em uma página
   * @param pagina - Página do PDF
   * @param texto - Texto a ser desenhado
   * @param x - Posição X
   * @param y - Posição Y
   * @param fonte - Fonte a ser usada
   * @param tamanho - Tamanho da fonte
   * @param cor - Cor do texto (padrão: preto)
   */
  desenharTexto(
    pagina: any,
    texto: string,
    x: number,
    y: number,
    fonte: any,
    tamanho: number,
    cor = rgb(0, 0, 0)
  ) {
    pagina.drawText(texto, {
      x,
      y,
      font: fonte,
      size: tamanho,
      color: cor,
    });
  }
  
  /**
   * Cria um cabeçalho para o documento
   * @param pagina - Página do PDF
   * @param titulo - Título do cabeçalho
   * @param fonte - Fonte a ser usada
   * @param margemSuperior - Margem superior
   * @param margem - Margem lateral
   * @returns Posição Y após o cabeçalho
   */
  criarCabecalho(
    pagina: any,
    titulo: string,
    fonte: any,
    margemSuperior: number,
    margem: number
  ): number {
    const yPos = pagina.getHeight() - margemSuperior;
    
    this.desenharTexto(
      pagina,
      titulo,
      margem,
      yPos,
      fonte,
      18,
      rgb(0, 0, 0.7)
    );
    
    // Linha separadora
    pagina.drawLine({
      start: { x: margem, y: yPos - 10 },
      end: { x: pagina.getWidth() - margem, y: yPos - 10 },
      thickness: 1,
      color: rgb(0, 0, 0.5),
    });
    
    return yPos - 30; // Retorna a posição Y após o cabeçalho
  }
  
  /**
   * Cria um rodapé para o documento
   * @param pagina - Página do PDF
   * @param texto - Texto do rodapé
   * @param fonte - Fonte a ser usada
   * @param margem - Margem
   */
  criarRodape(pagina: any, texto: string, fonte: any, margem: number) {
    const yPos = margem / 2;
    
    this.desenharTexto(
      pagina,
      texto,
      margem,
      yPos,
      fonte,
      8,
      rgb(0.5, 0.5, 0.5)
    );
  }

  private async getConfiguracao() {
    try {
      // Buscar configuração ou usar valores padrão
      // Removendo campos que não existem no modelo
      const config = await prisma.configuracaoDocumento.findFirst({
        orderBy: { criadoEm: 'desc' },
        select: {
          id: true,
          timbradoUrl: true,
          timbradoMarginTop: true,
          timbradoMarginBottom: true,
          timbradoMarginLeft: true,
          timbradoMarginRight: true,
          criadoEm: true,
          templatePadrao: true,
          margensTemplate: true
        }
      });

      console.log('Configuração encontrada:', config); // Debug

      // Retornar configuração padrão se não existir
      return {
        // Valores padrão para campos que não existem mais no modelo
        cabecalhoHtml: `
          <div style="text-align: center; padding: 20px;">
            <h2 style="margin:0;font-size:14pt">{{escritorio.nome}}</h2>
          </div>
        `,
        rodapeHtml: `
          <div style="text-align: center; font-size: 10pt;">
            {{escritorio.endereco}}<br>
            Tel: {{escritorio.telefone}} | Email: {{escritorio.email}}
          </div>
        `,
        // Campos que existem no modelo
        timbradoUrl: config?.timbradoUrl || '',
        timbradoMarginTop: config?.timbradoMarginTop || 100,
        timbradoMarginBottom: config?.timbradoMarginBottom || 50,
        timbradoMarginLeft: config?.timbradoMarginLeft || 50,
        timbradoMarginRight: config?.timbradoMarginRight || 50,
        templatePadrao: config?.templatePadrao || false,
        margensTemplate: config?.margensTemplate || false
      };
    } catch (error) {
      console.error('Erro ao buscar configuração:', error);
      // Returnar configuração padrão em caso de erro para não interromper o fluxo
      return {
        cabecalhoHtml: `<div style="text-align: center; padding: 20px;"><h2 style="margin:0;font-size:14pt">Documento</h2></div>`,
        rodapeHtml: `<div style="text-align: center; font-size: 10pt;">Documento gerado pelo sistema</div>`,
        timbradoUrl: '',
        timbradoMarginTop: 113,
        timbradoMarginBottom: 35,
        timbradoMarginLeft: 35,
        timbradoMarginRight: 00,
        templatePadrao: false,
        margensTemplate: false
      };
    }
  }

  private gerarHTML(content: string, config: any) {
    // Corrigir a URL do timbrado para garantir o caminho completo sem importar o ambiente
    const timbradoUrl = config.timbradoUrl 
      ? `${process.env.FRONTEND_URL || 'http://localhost:5000'}${config.timbradoUrl.startsWith('/') ? '' : '/'}${config.timbradoUrl}`
      : '';

    console.log('Gerando PDF com timbrado (URL completa):', timbradoUrl);

    return `
      <!DOCTYPE html>
      <html>
      <head>
        <meta charset="UTF-8">
        <style>
          @import url('https://fonts.googleapis.com/css2?family=Fira+Sans:wght@400;500;600&display=swap');
          
          @page { 
            margin: 0;
            size: A4;
          }
          
          body { 
            margin: 0;
            padding: 0;
            font-family: 'Fira Sans', Arial, sans-serif !important;
            font-size: 11pt;
            line-height: 1.5;
            position: relative;
            min-height: 100vh;
          }

          .page {
            position: relative;
            width: 21cm;
            min-height: 29.7cm;
            padding: ${config.timbradoMarginTop || 100}px ${config.timbradoMarginRight || 50}px ${config.timbradoMarginBottom || 50}px ${config.timbradoMarginLeft || 50}px;
            box-sizing: border-box;
            background-image: ${timbradoUrl ? `url('${timbradoUrl}')` : 'none'};
            background-size: cover;
            background-position: center;
            background-repeat: no-repeat;
          }

          .content {
            position: relative;
            z-index: 1;
            font-family: 'Fira Sans', Arial, sans-serif !important;
          }

          /* Garantir que todos os elementos herdam a fonte */
          * {
            font-family: 'Fira Sans', Arial, sans-serif !important;
          }
        </style>
      </head>
      <body>
        <div class="page">
          <div class="content">
            ${content}
          </div>
        </div>
      </body>
      </html>
    `;
  }

  async gerarPDF(html: string): Promise<Buffer> {
    try {
      console.log('Buscando configurações do documento...');
      const config = await this.getConfiguracao();
      console.log('Configurações aplicadas:', {
        timbradoUrl: config.timbradoUrl,
        margens: {
          top: config.timbradoMarginTop,
          bottom: config.timbradoMarginBottom,
          left: config.timbradoMarginLeft,
          right: config.timbradoMarginRight
        }
      });
      
      // Gerar HTML com as configurações
      const htmlCompleto = this.gerarHTML(html, config);
      
      console.log('Iniciando geração de PDF com Chromium...');
      
      const browser = await puppeteer.launch({
        executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/chromium-browser',
        headless: true,
        args: [
          '--no-sandbox',
          '--disable-setuid-sandbox',
          '--disable-dev-shm-usage',
          '--disable-gpu',
          '--font-render-hinting=medium',
          '--enable-font-antialiasing'
        ],
        ignoreHTTPSErrors: true
      });

      console.log('Navegador iniciado com sucesso');
      
      try {
        const page = await browser.newPage();
        
        // Garantir que fontes externas sejam carregadas
        await page.setExtraHTTPHeaders({
          'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7'
        });
        
        // Viewport A4
        await page.setViewport({
          width: 1240,
          height: 1754,
          deviceScaleFactor: 1.5
        });
        
        page.setDefaultNavigationTimeout(60000);
        
        console.log('Carregando conteúdo HTML...');
        
        // Configurar avaliação de JavaScript
        await page.setJavaScriptEnabled(true);
        
        // Esperar que o conteúdo e recursos sejam carregados
        await page.setContent(htmlCompleto, { 
          waitUntil: 'networkidle0',
          timeout: 60000
        });
        
        // Espera adicional para garantir carregamento de fontes e imagens
        await new Promise(resolve => setTimeout(resolve, 2000));
        
        // Injetar CSS adicional para forçar a fonte
        await page.addStyleTag({
          content: `
            @import url('https://fonts.googleapis.com/css2?family=Fira+Sans:wght@400;500;600&display=swap');
            body, * { font-family: 'Fira Sans', Arial, sans-serif !important; }
          `
        });
        
        console.log('Gerando PDF...');
        const pdf = await page.pdf({
          format: 'A4',
          printBackground: true,
          margin: { 
            top: '10mm', 
            right: '10mm', 
            bottom: '10mm', 
            left: '10mm' 
          },
          preferCSSPageSize: true,
          displayHeaderFooter: false
        });

        console.log('PDF gerado com sucesso!');
        return Buffer.from(pdf);
      } finally {
        await new Promise(resolve => setTimeout(resolve, 1000));
        await browser.close();
        console.log('Navegador fechado com segurança');
      }
    } catch (error) {
      console.error('Erro detalhado ao gerar PDF:', error);
      try {
        console.log('Tentando gerar PDF alternativo com pdf-lib...');
        
        // Criar um documento PDF simples com o conteúdo
        const pdfDoc = await PDFDocument.create();
        const page = pdfDoc.addPage([595, 842]); // A4
        
        const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
        
        // Adicionar texto informativo
        page.drawText('Não foi possível gerar o PDF com o layout desejado', {
          x: 50,
          y: 800,
          size: 16,
          font
        });
        
        page.drawText('Por favor, entre em contato com o suporte.', {
          x: 50,
          y: 750,
          size: 12,
          font
        });
        
        // Adicionar parte do HTML como texto simples (até 1000 caracteres)
        const plainText = html.replace(/<[^>]*>/g, ' ').slice(0, 1000) + '...';
        
        page.drawText('Conteúdo original (parcial):', {
          x: 50,
          y: 700,
          size: 10,
          font
        });
        
        // Quebrar o texto em linhas
        const linhas = [];
        for (let i = 0; i < plainText.length; i += 80) {
          linhas.push(plainText.substring(i, i + 80));
        }
        
        // Adicionar no máximo 30 linhas
        linhas.slice(0, 30).forEach((linha, index) => {
          page.drawText(linha, {
            x: 50,
            y: 670 - (index * 15),
            size: 8,
            font
          });
        });
        
        const pdfBytes = await pdfDoc.save();
        return Buffer.from(pdfBytes);
        
      } catch (fallbackError) {
        console.error('Erro também no método alternativo:', fallbackError);
        throw new Error('Falha ao gerar PDF: não foi possível criar o documento');
      }
    }
  }
}