import { provaQueue } from '../workers/ProvaWorker';
import { prisma } from '../config/database';
import { createHash } from 'crypto';
import { PDFDocument, StandardFonts } from 'pdf-lib';
import * as OpenTimestamps from 'opentimestamps';
import sharp from 'sharp';
import { promises as fs } from 'fs';

export class ProvaService {
  private fileValidator: FileValidator;
  private reportGenerator: ReportGenerator;

  constructor() {
    this.fileValidator = new FileValidator();
    this.reportGenerator = new ReportGenerator();
  }

  async processFile(file: Express.Multer.File, metadata: any) {
    try {
      console.log('Iniciando processamento do arquivo:', file.originalname); // Debug log

      // Validar arquivo e metadados
      if (!file.buffer || !file.originalname) {
        throw new Error('Arquivo inválido');
      }

      // Criar registro inicial
      const prova = await prisma.prova.create({
        data: {
          fileName: file.originalname,
          mimeType: file.mimetype,
          status: 'PENDENTE',
          metadata: {
            ...metadata,
            fileSize: file.size,
            originalName: file.originalname
          }
        }
      });

      console.log('Registro criado com sucesso:', prova.id); // Debug log

      // Adicionar à fila
      await provaQueue.add('processar-prova', {
        provaId: prova.id,
        fileData: file.buffer.toString('base64'),
        metadata
      });

      return prova;
    } catch (error) {
      console.error('Erro detalhado no processamento:', error);
      throw new Error(`Erro ao processar arquivo ${file.originalname}: ${error.message}`);
    }
  }

  private generateChecksums(buffer: Buffer) {
    return {
      sha256: createHash('sha256').update(buffer).digest('hex'),
      sha512: createHash('sha512').update(buffer).digest('hex'),
      md5: createHash('md5').update(buffer).digest('hex')
    };
  }

  private async registerTimestamp(buffer: Buffer) {
    const digest = createHash('sha256').update(buffer).digest();
    const timestamp = await OpenTimestamps.stamp(digest);
    return timestamp;
  }

  private async processFileByType(file: Express.Multer.File) {
    if (file.mimetype.startsWith('image/')) {
      return await this.processImage(file.buffer);
    }
    return file.buffer;
  }

  private async processImage(buffer: Buffer) {
    return await sharp(buffer)
      .resize(1200, 900, {
        fit: 'inside',
        withoutEnlargement: true
      })
      .toBuffer();
  }

  private async generateReport(data: any) {
    const pdfDoc = await PDFDocument.create();
    const page = pdfDoc.addPage();
    const font = await pdfDoc.embedFont(StandardFonts.Helvetica);

    // Adicionar conteúdo ao PDF
    // ... implementar a geração do relatório ...

    return {
      path: '/path/to/report.pdf',
      buffer: await pdfDoc.save()
    };
  }

  async verifyFile(hash: string) {
    try {
      const prova = await prisma.prova.findFirst({
        where: { checksumSha256: hash }
      });

      if (!prova) {
        return {
          verified: false,
          message: 'Documento não encontrado ou hash inválido'
        };
      }

      // Verificar se o arquivo ainda existe
      const filePath = prova.filePath;
      if (filePath) {
        try {
          await fs.access(filePath);
        } catch {
          return {
            verified: false,
            message: 'Arquivo original não encontrado'
          };
        }
      }

      return {
        verified: true,
        message: 'Documento verificado com sucesso',
        prova: {
          fileName: prova.fileName,
          checksumSha256: prova.checksumSha256,
          checksumSha512: prova.checksumSha512,
          checksumMd5: prova.checksumMd5,
          timestamp: prova.timestamp,
          metadata: prova.metadata,
          dataCriacao: prova.dataCriacao,
          dataValida: prova.dataAtualizacao
        },
        timestamp: prova.timestamp ? JSON.parse(prova.timestamp) : null
      };
    } catch (error) {
      console.error('Erro ao verificar arquivo:', error);
      throw new Error(`Erro ao verificar arquivo: ${error.message}`);
    }
  }
}