import { mydb } from "./mySupabase.ts";

/**
 * Registra uma ação do usuário na tabela user_actions
 */
export async function logUserAction(
  userId: string | null | undefined,
  externalUserId: string | null | undefined,
  actionCategory: string,
  actionType: string,
  actionDescription: string,
  resourceType?: string,
  resourceId?: string,
  oldData?: Record<string, unknown>,
  newData?: Record<string, unknown>,
  status: string = "success",
  errorMessage?: string,
  ipAddress?: string,
  userAgent?: string
) {
  try {
    const actionRes = await mydb.from("user_actions").insert({
      user_id: userId || null,
      external_user_id: externalUserId || null,
      action_category: actionCategory,
      action_type: actionType,
      action_description: actionDescription,
      resource_type: resourceType || null,
      resource_id: resourceId || null,
      old_data: oldData || null,
      new_data: newData || null,
      status,
      error_message: errorMessage || null,
      ip_address: ipAddress || null,
      user_agent: userAgent || null,
    });

    if (actionRes.error) {
      console.warn("[logUserAction] Erro ao registrar ação:", actionRes.error);
    }

    return actionRes;
  } catch (error) {
    console.error("[logUserAction] Erro ao registrar ação:", error);
    return null;
  }
}

/**
 * Cria uma sessão de usuário
 */
export async function createUserSession(
  userId: string,
  externalUserId?: string,
  ipAddress?: string,
  userAgent?: string,
  authMethod: string = "password"
) {
  try {
    const sessionRes = await mydb
      .from("user_sessions")
      .insert({
        user_id: userId,
        external_user_id: externalUserId || null,
        ip_address: ipAddress || null,
        user_agent: userAgent || null,
        auth_method: authMethod,
        status: "active",
      })
      .select()
      .single();

    if (sessionRes.error) {
      console.warn(
        "[createUserSession] Erro ao criar sessão:",
        sessionRes.error
      );
      return null;
    }

    return sessionRes.data;
  } catch (error) {
    console.error("[createUserSession] Erro ao criar sessão:", error);
    return null;
  }
}

/**
 * Finaliza uma sessão do usuário
 */
export async function endUserSession(sessionId: string) {
  try {
    const now = new Date();
    const res = await mydb
      .from("user_sessions")
      .select("login_at")
      .eq("id", sessionId)
      .single();

    if (!res.data) {
      return null;
    }

    const loginTime = new Date(res.data.login_at);
    const durationSeconds = Math.round(
      (now.getTime() - loginTime.getTime()) / 1000
    );

    const updateRes = await mydb
      .from("user_sessions")
      .update({
        logout_at: now.toISOString(),
        status: "expired",
        duration_seconds: durationSeconds,
      })
      .eq("id", sessionId)
      .select()
      .single();

    return updateRes.data;
  } catch (error) {
    console.error("[endUserSession] Erro ao finalizar sessão:", error);
    return null;
  }
}

/**
 * Incrementa o contador de ações na sessão
 */
export async function incrementSessionActionCount(sessionId: string) {
  try {
    await mydb
      .from("user_sessions")
      .update({
        action_count: mydb.rpc("increment", { row_id: sessionId }),
      })
      .eq("id", sessionId);
  } catch (error) {
    console.error("[incrementSessionActionCount] Erro:", error);
  }
}
