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';

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()
    };
  }
}