import { createClient as createSupabaseClient } from "@supabase/supabase-js";
import type { AIWorkspaceContext, AIWorkspaceMemoryRecord } from "./types";

function getSupabaseAdmin() {
  return createSupabaseClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SUPABASE_SERVICE_ROLE_KEY!
  );
}

async function getAccessibleTeamIds(userId: string) {
  const supabase = getSupabaseAdmin();
  const [ownedTeams, memberships] = await Promise.all([
    supabase.from("teams").select("id").eq("owner_id", userId),
    supabase.from("team_members").select("team_id").eq("user_id", userId),
  ]);

  return Array.from(
    new Set([
      ...(ownedTeams.data || []).map((team) => team.id),
      ...(memberships.data || []).map((membership) => membership.team_id),
    ])
  );
}

async function resolveTeamScope(userId: string, context?: AIWorkspaceContext) {
  const requestedTeamId = context?.activeTeamId || null;
  if (!requestedTeamId) return null;

  const accessibleTeamIds = await getAccessibleTeamIds(userId);
  return accessibleTeamIds.includes(requestedTeamId) ? requestedTeamId : null;
}

export async function getWorkspaceMemory(
  userId: string,
  context?: AIWorkspaceContext
): Promise<AIWorkspaceMemoryRecord | null> {
  const supabase = getSupabaseAdmin();
  const teamId = await resolveTeamScope(userId, context);

  const query = supabase.from("ai_workspace_memory").select("*").limit(1);
  const { data } = teamId
    ? await query.eq("team_id", teamId).maybeSingle()
    : await query.eq("user_id", userId).is("team_id", null).maybeSingle();

  return (data as AIWorkspaceMemoryRecord | null) || null;
}

export async function saveWorkspaceMemory(input: {
  userId: string;
  memory: string;
  source?: string;
  context?: AIWorkspaceContext;
}) {
  const supabase = getSupabaseAdmin();
  const memory = input.memory.trim();
  const teamId = await resolveTeamScope(input.userId, input.context);
  const existing = await getWorkspaceMemory(input.userId, input.context);

  if (!memory) {
    if (existing) {
      await supabase.from("ai_workspace_memory").delete().eq("id", existing.id);
    }

    return null;
  }

  const payload = {
    user_id: teamId ? null : input.userId,
    team_id: teamId,
    memory,
    source: input.source?.trim() || "manual",
  };

  if (existing) {
    const { data, error } = await supabase
      .from("ai_workspace_memory")
      .update(payload)
      .eq("id", existing.id)
      .select("*")
      .single();

    if (error) throw error;
    return data as AIWorkspaceMemoryRecord;
  }

  const { data, error } = await supabase
    .from("ai_workspace_memory")
    .insert(payload)
    .select("*")
    .single();

  if (error) throw error;
  return data as AIWorkspaceMemoryRecord;
}