/**
 * Utilitário centralizado para gerenciamento de dados de funcionários
 * Garante consultas válidas e evita erros de colunas inexistentes
 * 
 * IMPORTANTE: Recebe a instância do Supabase como parâmetro para evitar
 * problemas de importação entre server/client components
 */

import type { SupabaseClient } from "@supabase/supabase-js";

export interface EmployeeProfile {
  user_id: string;
  full_name: string | null;
  avatar_url?: string | null;
  phone?: string | null;
  created_at?: string;
  updated_at?: string;
}

export interface BasicProfile {
  id: string;
  // Nota: A tabela profiles padrão do Supabase não tem full_name
  // Usamos apenas o ID para referência
}

/**
 * Busca perfis de funcionários em lote por IDs de usuário
 * @param supabase Instância autenticada do Supabase
 * @param userIds Array de user_ids para buscar
 * @returns Map com user_id -> nome do funcionário
 */
export async function getEmployeeProfilesBatch(
  supabase: SupabaseClient,
  userIds: string[]
): Promise<Record<string, string>> {
  if (!userIds || userIds.length === 0) return {};

  try {
    console.log("🔍 [DEBUG] Buscando employee_profiles para user_ids:", userIds);
    
    // Consulta validada - apenas colunas que existem na tabela employee_profiles
    const { data: employees, error } = await supabase
      .from("employee_profiles")
      .select("user_id, full_name")
      .in("user_id", userIds);

    if (error) {
      console.error("❌ Erro ao buscar employee_profiles em lote:", error);
      return {};
    }
    
    console.log("✅ [DEBUG] Resultado da consulta employee_profiles:", {
      userIds,
      employeesCount: employees?.length,
      employees: employees
    });

    // Cria mapa de user_id -> nome
    const employeeMap: Record<string, string> = {};
    
    employees?.forEach(employee => {
      if (employee.full_name) {
        employeeMap[employee.user_id] = employee.full_name;
      }
    });

    return employeeMap;
  } catch (error) {
    console.error("Erro inesperado em getEmployeeProfilesBatch:", error);
    return {};
  }
}

/**
 * Resolve o nome do criador com fallback hierárquico
 * @param supabase Instância autenticada do Supabase
 * @param userId ID do usuário criador
 * @param ownerId ID do dono da empresa (para identificar admin)
 * @returns Nome formatado do criador
 */
export async function resolveCreatorName(
  supabase: SupabaseClient,
  userId: string, 
  ownerId?: string
): Promise<string> {
  if (!userId) return "Usuário";
  
  // Se é o dono da empresa
  if (ownerId && userId === ownerId) {
    return "Empresa (Admin)";
  }

  try {
    // Primeiro tenta buscar no employee_profiles
    const { data: employee, error } = await supabase
      .from("employee_profiles")
      .select("full_name")
      .eq("user_id", userId)
      .maybeSingle();

    if (!error && employee?.full_name) {
      return employee.full_name;
    }

    // Fallback para "Usuário" se não encontrar
    return "Usuário";

  } catch (error) {
    console.error("Erro ao resolver nome do criador:", error);
    return "Usuário";
  }
}

/**
 * Versão em lote do resolveCreatorName para múltiplos usuários
 * @param supabase Instância autenticada do Supabase
 * @param userMap Mapa de user_id -> owner_id (para verificar se é admin)
 * @returns Mapa com user_id -> nome formatado
 */
export async function resolveCreatorNamesBatch(
  supabase: SupabaseClient,
  userMap: Record<string, { isOwner?: boolean }>
): Promise<Record<string, string>> {
  const userIds = Object.keys(userMap);
  if (userIds.length === 0) return {};

  try {
    const employeeMap = await getEmployeeProfilesBatch(supabase, userIds);
    
    const result: Record<string, string> = {};
    
    for (const userId of userIds) {
      if (userMap[userId]?.isOwner) {
        result[userId] = "Empresa (Admin)";
      } else {
        result[userId] = employeeMap[userId] || "Usuário";
      }
    }

    return result;
  } catch (error) {
    console.error("Erro em resolveCreatorNamesBatch:", error);
    
    // Fallback básico
    const fallback: Record<string, string> = {};
    for (const userId of userIds) {
      fallback[userId] = userMap[userId]?.isOwner ? "Empresa (Admin)" : "Usuário";
    }
    return fallback;
  }
}

/**
 * Valida se uma consulta à employee_profiles é segura
 * @param columns Colunas solicitadas
 * @returns Array de colunas válidas
 */
export function validateEmployeeColumns(columns: string[]): string[] {
  const validColumns = ["user_id", "full_name", "avatar_url", "phone", "created_at", "updated_at"];
  return columns.filter(col => validColumns.includes(col));
}

/**
 * Logger para debug de consultas de funcionários
 */
export function logEmployeeQuery(
  context: string, 
  userIds: string[], 
  resultCount?: number, 
  error?: { message?: string } | null
) {
  if (process.env.NODE_ENV === 'development') {
    console.log(`[EmployeeUtils] ${context}:`, {
      userIds,
      resultCount,
      error: error?.message
    });
  }
}