import { Effect, Schema } from "effect";
import {
  SessionGoalResponseSchema,
  type SessionGoal,
  type SessionGoalPatch,
} from "@shared/agent/session-goal";
import type { SessionUsageTotals } from "@shared/agent/session-summary";
import { requestDecodedEffect } from "@/lib/api/request-json";
import {
  parseAgentTurnCommandResult,
  type AgentTurnCommandResult,
} from "@/features/agent/messages";
import type { AgentQueueAction, AgentToolAccess } from "@shared/agent/agent-turn";
import type { AgentImageInput } from "@shared/agent/agent-image-input";
import type { BrowserBackend } from "@/features/agent/tools/types";
import type {
  ComposerPromptTemplateRef,
  ComposerSkillRef,
} from "@/features/agent/composer-context";

import {
  RuntimeActivityPayloadSchema,
  RuntimeStatusSchema,
  RuntimeStatusResponseSchema,
  type RuntimeActivityPayload,
  type RuntimeContextUsage,
  type RuntimeSessionSummary,
  type RuntimeStatus,
} from "@shared/agent/runtime-status";
export type { RuntimeActivityPayload, RuntimeContextUsage, RuntimeSessionSummary, RuntimeStatus };
export type { SessionUsageTotals };

const decodeActivityOption = Schema.decodeUnknownOption(RuntimeActivityPayloadSchema, {
  onExcessProperty: "preserve",
});
const decodeStatusResponseOption = Schema.decodeUnknownOption(RuntimeStatusResponseSchema, {
  onExcessProperty: "preserve",
});

function decodeRuntimeActivityPayload(raw: unknown): RuntimeActivityPayload | null {
  const option = decodeActivityOption(raw);
  return option._tag === "Some" ? option.value : null;
}

function decodeRuntimeStatusResponse(raw: unknown): RuntimeStatus | null {
  const option = decodeStatusResponseOption(raw);
  return option._tag === "Some" ? (option.value.status ?? null) : null;
}

const AbortSessionResponseSchema = Schema.Struct({
  ok: Schema.Boolean,
  cleared: Schema.Struct({
    steering: Schema.Array(Schema.String),
    followUp: Schema.Array(Schema.String),
  }),
  status: RuntimeStatusSchema,
});

const decodeAbortSessionResponse = Schema.decodeUnknownOption(AbortSessionResponseSchema, {
  onExcessProperty: "preserve",
});

export type AbortSessionResult = {
  steering: string[];
  followUp: string[];
  status?: RuntimeStatus;
};

export function parseAbortSessionResult(input: unknown): AbortSessionResult {
  const decoded = decodeAbortSessionResponse(input);
  return decoded._tag === "Some"
    ? {
        steering: [...decoded.value.cleared.steering],
        followUp: [...decoded.value.cleared.followUp],
        status: decoded.value.status,
      }
    : { steering: [], followUp: [] };
}

export function loadRuntimeStatus(
  sessionId: string,
  piSessionId?: string | null,
): Promise<RuntimeStatus | null> {
  const params = new URLSearchParams({ sessionId });
  if (piSessionId) params.set("piSessionId", piSessionId);
  return Effect.runPromise(
    requestDecodedEffect(
      `/api/agent/runtime/status?${params.toString()}`,
      decodeRuntimeStatusResponse,
      { cache: "no-store" },
    ).pipe(Effect.catch(() => Effect.succeed(null))),
  );
}

export function abortSession(
  sessionId: string,
  piSessionId?: string | null,
): Promise<AbortSessionResult> {
  return Effect.runPromise(
    requestDecodedEffect("/api/agent/abort", parseAbortSessionResult, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ sessionId, piSessionId }),
    }).pipe(Effect.catch(() => Effect.succeed({ steering: [], followUp: [] }))),
  );
}

export function respondExtensionUi(
  sessionId: string,
  requestId: string,
  response: { value?: string; confirmed?: boolean; cancelled?: boolean },
): Promise<void> {
  return Effect.runPromise(
    requestDecodedEffect(
      "/api/agent/runtime/extension-ui",
      () => undefined,
      {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ sessionId, requestId, ...response }),
      },
      "Extension response was rejected",
    ),
  );
}

export type CanonicalSessionMeta = {
  title: string | null;
  modelId: string | null;
  startedAt: string | null;
  piSessionId: string | null;
  usage?: SessionUsageTotals | null;
};

export type CanonicalSessionResult = {
  messages: import("@/features/agent/messages").ChatMessage[];
  tokenStats?: import("@/features/agent/messages").TokenStats;
  // Byte-offset cursor to pass as `before` to load the previous (older) page,
  // or null when this page already reaches the start of the session log.
  cursor: number | null;
  // Session metadata from a head-scan; present on an initial tail load only.
  meta: CanonicalSessionMeta | null;
};

// Default page size for the initial tail load — enough to fill a long scrollback
// while keeping a giant log from being read/parsed whole.
export const DEFAULT_SESSION_TAIL = 500;

export type LoadCanonicalSessionOptions = { tail?: number; before?: number };

export function loadCanonicalSession(
  piSessionId: string,
  cwd: string,
  options: LoadCanonicalSessionOptions = {},
): Promise<CanonicalSessionResult> {
  const params = new URLSearchParams({ cwd });
  const tail = options.before === undefined ? (options.tail ?? DEFAULT_SESSION_TAIL) : undefined;
  if (tail !== undefined) params.set("tail", String(tail));
  if (options.before !== undefined) params.set("before", String(options.before));
  return Effect.runPromise(
    requestDecodedEffect(
      `/api/agent/sessions/${encodeURIComponent(piSessionId)}?${params.toString()}`,
      (input) => {
        const payload = input as Partial<CanonicalSessionResult>;
        return {
          messages: payload.messages ?? [],
          tokenStats: payload.tokenStats,
          cursor: payload.cursor ?? null,
          meta: payload.meta ?? null,
        };
      },
      { cache: "no-store" },
      "Failed to load session",
    ),
  );
}

export type CompactSessionArgs = {
  sessionId: string;
  modelId: string;
  thinkingLevel?: import("@shared/agent/agent-turn").AgentThinkingLevel;
  toolAccess?: AgentToolAccess;
  cwd?: string;
  piSessionId?: string | null;
  browserToolEnabled: boolean;
  browserSessionId?: string;
  browserBackend?: BrowserBackend;
  skills: ComposerSkillRef[];
  promptTemplates?: ComposerPromptTemplateRef[];
};

export type CompactSessionResult = {
  status?: RuntimeStatus;
};

export function compactSession(args: CompactSessionArgs): Promise<CompactSessionResult> {
  return Effect.runPromise(
    requestDecodedEffect(
      "/api/agent/compact",
      (input) => input as CompactSessionResult,
      {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(args),
      },
      "Compaction failed",
    ),
  );
}

export type SubmitTurnArgs = {
  sessionId: string;
  modelId: string;
  thinkingLevel?: import("@shared/agent/agent-turn").AgentThinkingLevel;
  toolAccess: AgentToolAccess;
  message: string;
  images?: AgentImageInput[];
  cwd?: string;
  piSessionId?: string | null;
  /** Control mode for steer/follow-up; omitted for a normal prompt. */
  mode?: "steer" | "follow_up";
  queueAction?: AgentQueueAction;
  queueReplacement?: string;
  browserToolEnabled: boolean;
  browserSessionId?: string;
  browserBackend?: BrowserBackend;
  skills: ComposerSkillRef[];
  promptTemplates?: ComposerPromptTemplateRef[];
};

export function submitTurnCommand(args: SubmitTurnArgs): Promise<AgentTurnCommandResult> {
  return Effect.runPromise(
    requestDecodedEffect(
      "/api/agent/turn",
      (input) => {
        const parsed = parseAgentTurnCommandResult(input);
        if (!parsed) throw new Error("Agent response was invalid");
        if (parsed.outcome === "rejected")
          throw new Error(parsed.error || "Agent request was rejected");
        return parsed;
      },
      {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(args),
      },
      "Agent request failed",
    ),
  );
}

export type RuntimeActivitySubscription = { close: () => void };

export function subscribeRuntimeActivity(
  onPayload: (payload: RuntimeActivityPayload) => void,
): RuntimeActivitySubscription {
  const source = new EventSource("/api/agent/runtime/activity");
  source.onmessage = (event) => {
    let parsed: unknown;
    try {
      parsed = JSON.parse(event.data);
    } catch {
      return;
    }
    const payload = decodeRuntimeActivityPayload(parsed);
    if (!payload) return;
    onPayload(payload);
  };
  return {
    close: () => source.close(),
  };
}

const decodeSessionGoalResponseOption = Schema.decodeUnknownOption(SessionGoalResponseSchema, {
  onExcessProperty: "preserve",
});

function decodeSessionGoal(raw: unknown): SessionGoal | null {
  if (!raw || typeof raw !== "object") return null;
  const option = decodeSessionGoalResponseOption(raw);
  return option._tag === "Some" ? option.value.goal : null;
}

const sessionGoalUrl = (piSessionId: string) =>
  `/api/agent/goal?piSessionId=${encodeURIComponent(piSessionId)}`;

export function loadSessionGoal(piSessionId: string): Promise<SessionGoal | null> {
  return Effect.runPromise(
    requestDecodedEffect(sessionGoalUrl(piSessionId), decodeSessionGoal, {
      cache: "no-store",
    }).pipe(Effect.catch(() => Effect.succeed(null))),
  );
}

export function updateSessionGoal(
  piSessionId: string,
  patch: SessionGoalPatch,
): Promise<SessionGoal | null> {
  return Effect.runPromise(
    requestDecodedEffect(
      sessionGoalUrl(piSessionId),
      decodeSessionGoal,
      {
        method: "PUT",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(patch),
      },
      "Failed to update the goal",
    ),
  );
}

export function clearSessionGoal(piSessionId: string): Promise<void> {
  return Effect.runPromise(
    requestDecodedEffect(
      sessionGoalUrl(piSessionId),
      () => undefined,
      { method: "DELETE" },
      "Failed to clear the goal",
    ),
  );
}