import { createClient } from "../../src/compat/supabase.js";
import { createLogger } from "./logger.tsx";
import { buscarColaboradorPorId, atualizarColaborador, type Colaborador } from "./colaboradores.tsx";

const logger = createLogger('FotoColaborador');

const supabase = createClient(
  Deno.env.get("SUPABASE_URL") ?? "",
  Deno.env.get("SUPABASE_SERVICE_ROLE_KEY") ?? "",
);

// Bucket PUBLICO (ao contrario dos documentos anexados, que sao privados) —
// uma foto de perfil nao e um documento sensivel e beneficia de ser servida
// directamente sem gerar signed URLs, tal como o bucket de imagens de artigo
// (make-7249dcd9-artigos-imagens) ja usado em uploads.tsx. Uma foto por
// colaborador: cada upload sobrescreve a anterior (upsert).
const BUCKET_NAME = "make-7249dcd9-rh-fotos";
const TAMANHO_MAXIMO_BYTES = 2 * 1024 * 1024; // 2MB
const TIPOS_MIME_PERMITIDOS = ["image/jpeg", "image/jpg", "image/png", "image/webp"];

async function initBucket() {
  try {
    const { data: buckets } = await supabase.storage.listBuckets();
    const existe = buckets?.some((bucket) => bucket.name === BUCKET_NAME);

    if (!existe) {
      const { error } = await supabase.storage.createBucket(BUCKET_NAME, {
        public: true,
        fileSizeLimit: TAMANHO_MAXIMO_BYTES,
      });
      if (error && !error.message?.includes("already exists")) {
        throw error;
      }
    }
  } catch (error) {
    logger.error("Erro ao inicializar bucket de fotos de colaborador:", error);
  }
}

try {
  await initBucket();
} catch (_error) {
  // Silenciado - nao deve impedir o arranque do servidor
}

function caminhoFoto(empresaId: string, colaboradorId: string, extensao: string): string {
  return `${empresaId}/${colaboradorId}.${extensao}`;
}

export async function uploadFotoColaborador(
  empresaId: string,
  colaboradorId: string,
  file: File,
): Promise<{ success: boolean; data?: Colaborador; error?: string }> {
  try {
    const colaborador = await buscarColaboradorPorId(colaboradorId);
    if (!colaborador || colaborador.empresaId !== empresaId) {
      return { success: false, error: "Colaborador não encontrado" };
    }

    if (file.size > TAMANHO_MAXIMO_BYTES) {
      return { success: false, error: "Ficheiro muito grande (máx 2MB)" };
    }

    if (!TIPOS_MIME_PERMITIDOS.includes(file.type)) {
      return { success: false, error: "Tipo de ficheiro inválido (use JPG, PNG ou WEBP)" };
    }

    const extensao = file.type === "image/png" ? "png" : file.type === "image/webp" ? "webp" : "jpg";
    const caminho = caminhoFoto(empresaId, colaboradorId, extensao);
    const buffer = new Uint8Array(await file.arrayBuffer());

    const { error: uploadError } = await supabase.storage
      .from(BUCKET_NAME)
      .upload(caminho, buffer, {
        contentType: file.type,
        cacheControl: "3600",
        upsert: true,
      });

    if (uploadError) {
      return { success: false, error: uploadError.message };
    }

    const { data: urlData } = supabase.storage.from(BUCKET_NAME).getPublicUrl(caminho);
    const fotoUrl = `${urlData.publicUrl}?v=${Date.now()}`; // cache-busting: mesmo caminho, novo upload

    const resultado = await atualizarColaborador(colaboradorId, { fotoUrl });
    logger.info(`Foto atualizada para colaborador ${colaboradorId}`);

    return resultado;
  } catch (error) {
    logger.error("Erro ao carregar foto de colaborador:", error);
    return { success: false, error: error.message };
  }
}

export async function removerFotoColaborador(
  empresaId: string,
  colaboradorId: string,
): Promise<{ success: boolean; data?: Colaborador; error?: string }> {
  try {
    const colaborador = await buscarColaboradorPorId(colaboradorId);
    if (!colaborador || colaborador.empresaId !== empresaId) {
      return { success: false, error: "Colaborador não encontrado" };
    }

    for (const extensao of ["jpg", "png", "webp"]) {
      await supabase.storage.from(BUCKET_NAME).remove([caminhoFoto(empresaId, colaboradorId, extensao)]);
    }

    const resultado = await atualizarColaborador(colaboradorId, { fotoUrl: undefined });
    logger.info(`Foto removida do colaborador ${colaboradorId}`);

    return resultado;
  } catch (error) {
    logger.error("Erro ao remover foto de colaborador:", error);
    return { success: false, error: error.message };
  }
}