import { createHash } from "crypto";

import sharp from "sharp";

export class FileValidator {
  async validateFile(buffer: Buffer, mimeType: string) {
    try {
      // Validação básica
      if (!buffer || buffer.length === 0) {
        return { valid: false, error: "Arquivo vazio" };
      }

      // Verificar tamanho máximo (10MB)
      const MAX_SIZE = 10 * 1024 * 1024;
      if (buffer.length > MAX_SIZE) {
        return { valid: false, error: "Arquivo muito grande (máximo 10MB)" };
      }

      // Verificar tipos de arquivo permitidos
      const allowedTypes = [
        "application/pdf",
        "image/jpeg",
        "image/png",
        "image/gif",
        "image.webp",
      ];

      if (!allowedTypes.includes(mimeType)) {
        return {
          valid: false,
          error: "Tipo de arquivo não suportado. Use PDF, JPEG, PNG ou GIF.",
        };
      }

      // Verificação adicional para JPEG
      if (mimeType === "image/jpeg") {
        try {
          // Verificar se é um JPEG válido tentando processá-lo
          await sharp(buffer).metadata();
        } catch (jpegError) {
          console.error("Erro ao validar JPEG:", jpegError);
          return {
            valid: false,
            error:
              "O arquivo JPEG parece estar corrompido. Tente salvar a imagem em um formato diferente e enviar novamente.",
          };
        }
      }

      return { valid: true };
    } catch (error) {
      console.error("Erro na validação de arquivo:", error);
      return {
        valid: false,
        error: `Erro ao validar arquivo: ${error.message}`,
      };
    }
  }

  async validateMetadata(metadata: any) {
    // Campos básicos obrigatórios
    const requiredFields = ["userAgent", "timestamp"];
    const missingFields = requiredFields.filter((field) => !metadata[field]);

    if (missingFields.length > 0) {
      return {
        valid: false,
        error: `Dados necessários ausentes: ${missingFields.join(", ")}`,
      };
    }

    return { valid: true };
  }

  generateHashes(buffer: Buffer) {
    return {
      sha256: createHash("sha256").update(buffer).digest("hex"),
      sha512: createHash("sha512").update(buffer).digest("hex"),
      md5: createHash("md5").update(buffer).digest("hex"),
    };
  }

  async cleanup() {
    // Nada a fazer nesta implementação simplificada
  }
}