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
      const config = await prisma.configuracaoDocumento.findFirst({
        orderBy: { criadoEm: 'desc' },
        select: {
          id: true,
          timbradoUrl: true,
          timbradoMarginTop: true,
          timbradoMarginBottom: true,
          timbradoMarginLeft: true,
          timbradoMarginRight: true,
          templatePadrao: true,
          margensTemplate: true,
          criadoEm: true
        }
      });

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

      // Retornar configuração padrão se não existir
      return {
        // Valores padrão
        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 || null,
        margensTemplate: config?.margensTemplate || null
      };
    } catch (error) {
      console.error('Erro ao buscar configuração:', error);
      // Retornar configuração padrão 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: 100,
        timbradoMarginBottom: 50,
        timbradoMarginLeft: 50,
        timbradoMarginRight: 50,
        templatePadrao: null,
        margensTemplate: null
      };
    }
  }

  /**
   * Gera um PDF a partir do conteúdo HTML e dados do escritório
   * @param conteudo - Conteúdo HTML para o PDF
   * @param escritorio - Dados do escritório para substituir no template
   * @returns Buffer contendo o PDF gerado
   */
  async gerarPDF(conteudo: string, escritorio: any = {}): Promise<Buffer> {
    try {
      console.log('Buscando configurações do documento...');
      const config = await this.getConfiguracao();
      
      // Verificar se temos um timbrado para usar
      const temTimbrado = !!config.timbradoUrl;
      
      console.log(`Iniciando geração de PDF ${temTimbrado ? 'com' : 'sem'} timbrado...`);
      
      // Se temos timbrado, vamos primeiro verificar se ele existe
      let timbradoPath = '';
      let timbradoExists = false;
      
      if (temTimbrado) {
        if (config.timbradoUrl.startsWith('/uploads')) {
          timbradoPath = path.join(process.cwd(), 'public', config.timbradoUrl);
        } else {
          timbradoPath = path.join(process.cwd(), 'public', 'uploads', path.basename(config.timbradoUrl));
        }
        
        console.log('Verificando timbrado em:', timbradoPath);
        
        try {
          await fs.access(timbradoPath);
          timbradoExists = true;
          console.log('Timbrado encontrado');
        } catch (e) {
          console.error('Timbrado não encontrado:', e);
        }
      }
      
      // Margens definidas no template ou padrão
      const margens = config.margensTemplate || {
        top: config.timbradoMarginTop || 100,
        left: config.timbradoMarginLeft || 50,
        right: config.timbradoMarginRight || 50,
        bottom: config.timbradoMarginBottom || 50
      };
      
      console.log('Usando margens:', margens);
      
      /**
       * Gera o PDF final combinando o timbrado com o conteúdo
       */
      const gerarPdfComTimbrado = async (
        content: string,
        pageW: number,
        pageH: number,
        margins: any,
        usesTimbrado: boolean,
        timbradoFilePath: string
      ): Promise<Buffer> => {
        console.log('Gerando PDF com timbrado...');

        // 1. Se tem timbrado, carregar e validar primeiro
        let timbradoTemplate = null;
        if (usesTimbrado) {
          try {
            const timbradoBytes = await fs.readFile(timbradoFilePath);
            const timbradoPdf = await PDFDocument.load(timbradoBytes);
            
            if (timbradoPdf.getPageCount() > 0) {
              // Criar um novo documento só para o template
              const templateDoc = await PDFDocument.create();
              const [templatePage] = await templateDoc.copyPages(timbradoPdf, [0]);
              templateDoc.addPage(templatePage);
              timbradoTemplate = templateDoc;
            }
          } catch (e) {
            console.error('Erro ao carregar timbrado, prosseguindo sem ele:', e);
          }
        }

        // 2. Gerar o PDF do conteúdo
        const browser = await puppeteer.launch({
          args: ['--no-sandbox', '--disable-setuid-sandbox'],
          headless: true
        });

        try {
          // Criar PDF do conteúdo
          const page = await browser.newPage();
          await page.setContent(`
            <!DOCTYPE html>
            <html>
              <head>
                <meta charset="UTF-8">
                <style>
                  @page { size: A4; margin: 0; }
                  body {
                    font-family: Arial, sans-serif;
                    font-size: 11pt;
                    line-height: 1.5;
                    margin: ${margins.top}px ${margins.right}px ${margins.bottom}px ${margins.left}px;
                    text-align: justify;
                  }
                  p { margin: 0 0 0.5em 0; text-align: justify; }
                  strong, b { font-weight: bold; }
                  em, i { font-style: italic; }
                  u { text-decoration: underline; }
                </style>
              </head>
              <body>${content}</body>
            </html>
          `, { waitUntil: 'networkidle0' });

          // Gerar PDF do conteúdo
          const contentBuffer = await page.pdf({
            format: 'A4',
            printBackground: true,
            margin: {
              top: '0',
              right: '0',
              bottom: '0',
              left: '0'
            }
          });

          // Se não tem timbrado válido, retornar apenas o conteúdo
          if (!timbradoTemplate) {
            return contentBuffer;
          }

          // 3. Combinar timbrado com conteúdo
          try {
            const contentPdf = await PDFDocument.load(contentBuffer);
            const finalPdf = await PDFDocument.create();

            // Para cada página do conteúdo
            for (let i = 0; i < contentPdf.getPageCount(); i++) {
              // Copiar a página do timbrado primeiro
              const [newTimbradoPage] = await finalPdf.copyPages(timbradoTemplate, [0]);
              finalPdf.addPage(newTimbradoPage);

              // Copiar e sobrepor o conteúdo
              const [contentPage] = await finalPdf.copyPages(contentPdf, [i]);
              const { width: contentWidth, height: contentHeight } = contentPage.getSize();

              // Ajustar as dimensões se necessário
              newTimbradoPage.drawPage(contentPage, {
                x: 0,
                y: 0,
                width: contentWidth,
                height: contentHeight,
                opacity: 1
              });
            }

            const finalBytes = await finalPdf.save();
            return Buffer.from(finalBytes);
          } catch (mergeError) {
            console.error('Erro ao combinar PDFs, retornando conteúdo original:', mergeError);
            return contentBuffer;
          }
        } finally {
          await browser.close();
        }
      };

      // Processar o conteúdo e gerar o PDF
      const processedContent = this.processarTemplate(conteudo, escritorio);
      const pageWidth = 595;
      const pageHeight = 842;
      const pdfBytes = await gerarPdfComTimbrado(
        processedContent,
        pageWidth,
        pageHeight,
        margens,
        timbradoExists,
        timbradoPath
      );
      console.log(`PDF gerado com sucesso: ${pdfBytes.length} bytes`);
      return pdfBytes;
    } catch (error) {
      console.error('Erro geral ao gerar PDF:', error);
      throw error;
    }
  }

  private processarTemplate(template: string, dados: any): string {
    return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
      const keyParts = key.trim().split('.');
      let value = dados;
      
      for (const part of keyParts) {
        if (value && typeof value === 'object' && part in value) {
          value = value[part];
        } else {
          value = undefined;
          break;
        }
      }
      
      return value !== undefined ? value : match;
    });
  }
}