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

type ActionResult = { id: string; label: string; rawAnalytics?: Record<string, unknown>; inActionMetrics?: { name: string; value: unknown; unit?: string }[] };
type SessionResult = { id: string; playerId: string; actions: ActionResult[] };

// Scoped to one generation: reuse reads without serving stale coach annotations
// to a later request or retaining player data in a process-wide cache.
class ReferenceCache {
  results = new Map<string, ActionResult[] | null>();
  pages = new Map<string, any[]>();
}

function numericMetrics(action: ActionResult) {
  const values = new Map<string, number>();
  const metrics = [...Object.entries(action.rawAnalytics ?? {}).map(([name, value]) => ({ name, value })), ...(action.inActionMetrics ?? [])];
  for (const metric of metrics) {
    const name = metric.name.toLowerCase().replace(/[^a-z0-9]/g, "");
    if (!name || name === "ballspeed" || /frames?$/.test(name)) continue;
    if (typeof metric.value === "number" && Number.isFinite(metric.value)) values.set(name, metric.value);
  }
  return values;
}

export function actionDistance(current: ActionResult, reference: ActionResult) {
  const target = numericMetrics(current);
  const values = numericMetrics(reference);
  if (!target.size) return null;
  let error = 0;
  let shared = 0;
  for (const [name, value] of target) {
    const other = values.get(name);
    if (other === undefined) { error++; continue; }
    error += ((value - other) / Math.max(Math.abs(value), Math.abs(other), 1)) ** 2;
    shared++;
  }
  return shared ? Math.sqrt(error / target.size) : null;
}

function ageContext(profile: Record<string, unknown>) {
  const value = profile.bdate;
  if (typeof value !== "string") return profile;
  const birth = new Date(`${value.slice(0, 10)}T00:00:00Z`);
  if (Number.isNaN(birth.getTime())) return profile;
  const now = new Date();
  let age = now.getUTCFullYear() - birth.getUTCFullYear();
  if (now.getUTCMonth() < birth.getUTCMonth() || (now.getUTCMonth() === birth.getUTCMonth() && now.getUTCDate() < birth.getUTCDate())) age--;
  return { ...profile, ageYears: age };
}

export async function analysisResults(sessionId: string, userId: string, isAdmin = false): Promise<SessionResult> {
  const response = await fetch(new URL(`/api/sessions/${sessionId}`, env.ANALYSIS_API_URL), {
    headers: {
      "x-sporalize-proxy-secret": env.ANALYSIS_PROXY_SECRET,
      "x-sporalize-user-id": userId,
      ...(isAdmin ? { "x-sporalize-admin": "true" } : {}),
    },
    signal: AbortSignal.timeout(120000),
  });
  if (!response.ok) throw new Error(`Unable to load results for session ${sessionId} (${response.status})`);
  return await response.json() as SessionResult;
}

export async function actionReferences(db: SupabaseClient, current: ActionResult, actionType: string, currentSession?: SessionResult, cache = new ReferenceCache()) {
  const closest = [];
  if (!numericMetrics(current).size) return [];
  const referenceResults = cache.results;
  if (currentSession) referenceResults.set(currentSession.id, currentSession.actions);
  for (let from = 0; ; from += 100) {
    const pageKey = JSON.stringify([actionType, from]);
    let examples = cache.pages.get(pageKey);
    if (!examples) {
      const { data, error: examplesError } = await db.from("annotations")
        .select("action_id,score,annotations_notes!inner(note),actions!inner(action_id,session_id,type,sessions!inner(user_id,player_id,players!inner(gender,bdate,height,weight,position)))")
        .eq("actions.type", actionType)
        .order("action_id").range(from, from + 99);
      if (examplesError) throw new Error(`Unable to load human annotations: ${examplesError.message}`);
      examples = data ?? [];
      cache.pages.set(pageKey, examples);
    }
    const referenceRows = (examples ?? []).filter((row: any) =>
      row.action_id !== current.id && (row.annotations_notes ?? []).some((note: { note: string }) => typeof note.note === "string" && note.note.trim().length > 0))
      .map((row: any) => ({ ...row, actions: Array.isArray(row.actions) ? row.actions[0] : row.actions }));
    const sessions = new Map<string, string>();
    for (const row of referenceRows) {
      const related = row.actions;
      if (related?.session_id && related.sessions?.user_id && !referenceResults.has(related.session_id)) {
        sessions.set(related.session_id, related.sessions.user_id);
      }
    }
    const pending = [...sessions];
    for (let offset = 0; offset < pending.length; offset += 5) {
      await Promise.all(pending.slice(offset, offset + 5).map(async ([id, ownerId]) => {
        try {
          const result = await analysisResults(id, ownerId);
          referenceResults.set(id, result.actions.map(({ id, label, rawAnalytics, inActionMetrics }) => ({ id, label, rawAnalytics, inActionMetrics })));
        } catch (error) {
          referenceResults.set(id, null);
          console.warn("Skipping unavailable annotation reference results", { sessionId: id, error });
        }
      }));
    }
    for (const row of referenceRows) {
      const related = row.actions;
      const refPlayerValue = related?.sessions?.players;
      const rawPlayer = Array.isArray(refPlayerValue) ? refPlayerValue[0] : refPlayerValue;
      const refPlayer = rawPlayer ? ageContext(rawPlayer as Record<string, unknown>) : rawPlayer;
      const refActions = related?.session_id ? referenceResults.get(related.session_id) : undefined;
      const refAction = refActions?.find((item) => item.id === row.action_id);
      if (!related || !refPlayer || !refAction || refAction.label.toLowerCase() !== actionType.toLowerCase()) continue;
      const distance = actionDistance(current, refAction);
      if (distance === null) continue;
      closest.push({ distance, reference: { session_id: related.session_id, action_id: row.action_id, action_type: related.type, player: refPlayer,
        results: { metrics: refAction.inActionMetrics ?? [], analytics: refAction.rawAnalytics ?? {} },
        score: row.score, notes: (row.annotations_notes ?? []).map((note: { note: string }) => note.note).filter((note: string) => typeof note === "string" && note.trim()) } });
    }
    closest.sort((a, b) => a.distance - b.distance || a.reference.action_id.localeCompare(b.reference.action_id));
    closest.splice(5);
    if ((examples ?? []).length < 100) break;
  }
  return closest.map((item) => item.reference);
}

export async function generateSessionFeedback(db: SupabaseClient, sessionId: string, userId: string) {
  if (!env.AGENT_API_URL || !env.AGENT_API_KEY) throw new Error("Agent service is not configured");
  const { data: session, error: sessionError } = await db.from("sessions")
    .select("session_id,player_id,players(player_id,bdate,height,weight,position,gender)")
    .eq("session_id", sessionId).eq("user_id", userId).maybeSingle();
  if (sessionError || !session) throw new Error(`Unable to load completed session context: ${sessionError?.message ?? "session missing"}`);
  const rawPlayer = Array.isArray(session.players) ? session.players[0] : session.players;
  const player = rawPlayer ? ageContext(rawPlayer as Record<string, unknown>) : rawPlayer;
  if (!player) throw new Error("Session player context is missing");
  const result = await analysisResults(sessionId, userId);
  const actionResults = new Map(result.actions.map((action) => [action.id, action]));
  const { data: currentActions, error: actionsError } = await db.from("actions")
    .select("action_id,type").eq("session_id", sessionId);
  if (actionsError) throw new Error(`Unable to load completed actions: ${actionsError.message}`);

  const actions = [];
  const referenceCache = new ReferenceCache();
  for (const action of currentActions ?? []) {
    const current = actionResults.get(action.action_id);
    if (!current) continue;
    const references = await actionReferences(db, current, action.type, result, referenceCache);
    actions.push({ action_id: action.action_id, action_type: action.type,
      results: { metrics: current.inActionMetrics ?? [], analytics: current.rawAnalytics ?? {} }, references });
  }
  if (!actions.length) return;
  const agentHeaders: Record<string, string> = {
    "content-type": "application/json",
    "x-api-key": env.AGENT_API_KEY,
    "x-user-id": userId,
  };
  if (env.HF_TOKEN) agentHeaders.authorization = `Bearer ${env.HF_TOKEN}`;
  const response = await fetch(new URL("/api/session/generate", env.AGENT_API_URL), {
    method: "POST",
    headers: agentHeaders,
    body: JSON.stringify({ session_id: sessionId, player, actions }),
    signal: AbortSignal.timeout(210000),
  });
  const payload = await response.json().catch(() => ({})) as {
    actions?: { action_id?: string; actionId?: string; feedback: string[] }[];
    session_feedback?: string[];
    sessionFeedback?: string[];
    detail?: string;
  };
  const sessionFeedback = payload.session_feedback ?? payload.sessionFeedback;
  const generatedActions = Array.isArray(payload.actions) ? payload.actions.map((item) => ({
    actionId: item?.action_id ?? item?.actionId,
    feedback: item?.feedback,
  })) : undefined;
  const requestedIds = new Set(actions.map((action) => action.action_id));
  const returnedIds = new Set(generatedActions?.map((item) => item.actionId));
  const validText = (value: unknown): value is string => typeof value === "string" && value.trim().length > 0;
  if (!response.ok || !Array.isArray(generatedActions) || generatedActions.length !== requestedIds.size
      || returnedIds.size !== requestedIds.size
      || generatedActions.some((item) => !item.actionId || !requestedIds.has(item.actionId)
        || !Array.isArray(item.feedback) || item.feedback.length === 0 || item.feedback.some((text) => !validText(text)))
      || !Array.isArray(sessionFeedback) || sessionFeedback.length === 0 || sessionFeedback.some((text) => !validText(text))) {
    throw new Error(payload.detail ?? `Agent generation failed (${response.status})`);
  }
  for (const item of generatedActions) {
    const actionId = item.actionId!;
    const { error } = await db.from("actions_feedbacks").delete().eq("action_id", actionId);
    if (error) throw new Error(`Unable to replace generated action feedback: ${error.message}`);
    if (item.feedback.length) {
      const inserted = await db.from("actions_feedbacks").insert(item.feedback.map((feedback) => ({ action_id: actionId, feedback })));
      if (inserted.error) throw new Error(`Unable to save generated action feedback: ${inserted.error.message}`);
    }
  }
  const { error: clearError } = await db.from("sessions_feedbacks").delete().eq("session_id", sessionId);
  if (clearError) throw new Error(`Unable to replace generated session feedback: ${clearError.message}`);
  const { error: saveError } = await db.from("sessions_feedbacks").insert(sessionFeedback.map((feedback) => ({ session_id: sessionId, feedback })));
  if (saveError) throw new Error(`Unable to save generated session feedback: ${saveError.message}`);
}