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();
      
      console.log('Iniciando geração de PDF com Chromium...');
      
      // 1. Primeiro gerar o PDF do conteúdo
      const browser = await puppeteer.launch({
        executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/chromium-browser',
        headless: true,
        args: ['--no-sandbox', '--disable-setuid-sandbox']
      });

      // Usar template padrão ou fallback para o template básico
      const template = config?.templatePadrao || `
        <!DOCTYPE html>
        <html>
          <head>
            <meta charset="UTF-8">
            <style>
              body {
                font-family: Arial, sans-serif;
                font-size: 11pt;
                line-height: 1.3;
                margin: 0;
                padding: 0;
              }
              
              .content {
                margin: 0;
                padding: 0;
                min-height: calc(100vh - 58mm);
                position: relative;
              }

              p { margin: 0.7em 0; }
              h1, h2, h3 { margin: 0.8em 0; }
            </style>
          </head>
          <body>
            <div class="content">
              ${conteudo}
            </div>
          </body>
        </html>
      `;

      // Processar o template substituindo variáveis
      const templateProcessado = template.replace(/\{\{(.+?)\}\}/g, (match, key) => {
        const keyParts = key.trim().split('.');
        let value = escritorio;
        
        for (const part of keyParts) {
          value = value?.[part];
          if (value === undefined) break;
        }
        
        return value || match;
      });
      
      let contentPdfBuffer;
      try {
        const page = await browser.newPage();
        await page.setContent(templateProcessado, { waitUntil: 'networkidle0' });
        
        // Usar margens do template se existirem
        const margens = config?.margensTemplate || {
          top: '35mm',
          bottom: '29mm',
          left: '25mm',
          right: '25mm'
        };
        
        contentPdfBuffer = await page.pdf({
          format: 'A4',
          margin: margens,
          printBackground: true
        });
        
        console.log('PDF do conteúdo gerado com sucesso:', contentPdfBuffer.length, 'bytes');
      } finally {
        await browser.close();
      }
      
      // 2. Verificar se existe timbrado para combinar
      if (config.timbradoUrl) {
        try {
          console.log('Combinando com timbrado...');
          
          // Caminho do arquivo timbrado
          let timbradoPath;
          
          // Se o caminho começa com /uploads, procurar na pasta public
          if (config.timbradoUrl.startsWith('/uploads')) {
            timbradoPath = path.join(process.cwd(), 'public', config.timbradoUrl);
          } else {
            timbradoPath = path.join(process.cwd(), 'public', 'uploads', 'Timbrado_2025.pdf');
          }
          
          console.log('Procurando timbrado em:', timbradoPath);
          
          // Verificar se o arquivo existe
          try {
            await fs.access(timbradoPath);
            console.log('Arquivo de timbrado encontrado');
          } catch (err) {
            console.error('Arquivo de timbrado não encontrado:', err);
            return contentPdfBuffer; // Retornar apenas o conteúdo se não encontrar o timbrado
          }
          
          // Ler o arquivo de timbrado
          const templateBytes = await fs.readFile(timbradoPath);
          console.log('Arquivo de timbrado lido:', templateBytes.length, 'bytes');
          
          // Carregar os PDFs
          const templateDoc = await PDFDocument.load(templateBytes);
          const contentDoc = await PDFDocument.load(contentPdfBuffer);
          
          // Criar documento final
          const pdfDoc = await PDFDocument.create();
          
          // Obter página do template e páginas do conteúdo
          const [templatePage] = await pdfDoc.copyPages(templateDoc, [0]);
          const contentPages = await pdfDoc.copyPages(contentDoc, contentDoc.getPageIndices());
          
          // Para cada página do conteúdo, criar uma página com template e conteúdo
          for (let i = 0; i < contentPages.length; i++) {
            // Adicionar página do template
            pdfDoc.addPage(templatePage);
            const page = pdfDoc.getPage(i);
            
            // Desenhar o conteúdo sobre o template
            page.drawPage(contentPages[i], {
              x: 0,
              y: 0,
              opacity: 1
            });
          }
          
          // Gerar PDF final
          const pdfBytes = await pdfDoc.save();
          console.log('PDF final gerado com sucesso:', pdfBytes.length, 'bytes');
          
          return Buffer.from(pdfBytes);
        } catch (err) {
          console.error('Erro ao combinar PDFs:', err);
          // Em caso de erro, retornar apenas o conteúdo
          return contentPdfBuffer;
        }
      }
      
      // Se não houver timbrado, retornar apenas o conteúdo
      return contentPdfBuffer;
    } catch (error) {
      console.error('Erro ao gerar PDF:', error);
      
      // Fallback simplificado em caso de erro
      try {
        console.log('Usando método alternativo de geração...');
        
        const pdfDoc = await PDFDocument.create();
        const page = pdfDoc.addPage([595, 842]); // A4
        const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
        
        // Adicionar texto básico
        page.drawText('Documento Gerado pelo Sistema', {
          x: 50,
          y: 800,
          font,
          size: 16
        });
        
        // Adicionar conteúdo como texto plano
        const plainText = conteudo.replace(/<[^>]*>/g, ' ').slice(0, 2000);
        const linhas = [];
        for (let i = 0; i < plainText.length; i += 80) {
          linhas.push(plainText.substring(i, i + 80));
        }
        
        linhas.forEach((linha, index) => {
          page.drawText(linha, {
            x: 50,
            y: 750 - (index * 15),
            font,
            size: 10
          });
        });
        
        const pdfBytes = await pdfDoc.save();
        return Buffer.from(pdfBytes);
      } catch (fallbackError) {
        console.error('Erro no método alternativo:', fallbackError);
        throw new Error('Falha ao gerar PDF');
      }
    }
  }

  // Método antigo mantido para compatibilidade
  async gerarPDFAntigo(html: string): Promise<Buffer> {
    try {
      const config = await this.getConfiguracao();
      const htmlCompleto = this.gerarHTML(html, config);
      
      const browser = await puppeteer.launch({
        executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/chromium-browser',
        headless: true,
        args: ['--no-sandbox', '--disable-setuid-sandbox']
      });
      
      const page = await browser.newPage();
      await page.setContent(htmlCompleto, { waitUntil: 'networkidle0' });
      
      const pdf = await page.pdf({
        format: 'A4',
        printBackground: true
      });
      
      await browser.close();
      return pdf;
    } catch (error) {
      console.error('Erro ao gerar PDF:', error);
      throw new Error('Falha ao gerar PDF');
    }
  }
}