// ---------------------------------------------------------------------------
// Boot-time sync — replays sources from executor.jsonc into the executor.
// Plugins upsert so a re-sync on an already-populated DB is a no-op.
// Write-back (DB → file) is handled by the ConfigFileSink passed to each
// plugin in executor.ts.
// ---------------------------------------------------------------------------

import { Cause, Effect, Match } from "effect";
import { join } from "node:path";
import * as fs from "node:fs";
import * as jsonc from "jsonc-parser";

import type {
  SourceConfig,
  ExecutorFileConfig,
  ConfigHeaderValue,
  McpAuthConfig,
} from "@executor-js/config";
import { SECRET_REF_PREFIX } from "@executor-js/config";
import type { ScopeId } from "@executor-js/sdk";
import type { McpConnectionAuthInput } from "@executor-js/plugin-mcp";

import type { LocalExecutor } from "./executor";

// ---------------------------------------------------------------------------
// Header translation: config format → plugin format
// ---------------------------------------------------------------------------

const translateHeader = (
  value: ConfigHeaderValue,
): string | { secretId: string; prefix?: string } => {
  if (typeof value === "string") {
    if (value.startsWith(SECRET_REF_PREFIX)) {
      return { secretId: value.slice(SECRET_REF_PREFIX.length) };
    }
    return value;
  }
  // Object form: { value, prefix? }
  if (typeof value.value === "string" && value.value.startsWith(SECRET_REF_PREFIX)) {
    return {
      secretId: value.value.slice(SECRET_REF_PREFIX.length),
      prefix: value.prefix,
    };
  }
  return value.value;
};

const translateHeaders = (
  headers: Record<string, ConfigHeaderValue> | undefined,
): Record<string, string | { secretId: string; prefix?: string }> | undefined => {
  if (!headers) return undefined;
  const out: Record<string, string | { secretId: string; prefix?: string }> = {};
  for (const [k, v] of Object.entries(headers)) {
    out[k] = translateHeader(v);
  }
  return out;
};

// MCP auth translation: file format → plugin format. The header variant
// stores credentials as `secret-public-ref:<id>`; the plugin SDK takes the
// raw secret id. The oauth2 variant is structurally identical.
export const translateMcpAuth = (
  auth: McpAuthConfig | undefined,
): McpConnectionAuthInput | undefined => {
  if (!auth) return undefined;
  if (auth.kind === "none") return { kind: "none" };
  if (auth.kind === "header") {
    const secretId = auth.secret.startsWith(SECRET_REF_PREFIX)
      ? auth.secret.slice(SECRET_REF_PREFIX.length)
      : auth.secret;
    return {
      kind: "header",
      headerName: auth.headerName,
      secretId,
      prefix: auth.prefix,
    };
  }
  return { kind: "oauth2", connectionId: auth.connectionId };
};

// ---------------------------------------------------------------------------
// Config path resolution
// ---------------------------------------------------------------------------

export const resolveConfigPath = (scopeDir: string): string => join(scopeDir, "executor.jsonc");

// ---------------------------------------------------------------------------
// Load config (sync, no Effect deps — runs at startup)
// ---------------------------------------------------------------------------

const loadConfigSync = (path: string): ExecutorFileConfig | null => {
  if (!fs.existsSync(path)) return null;
  const raw = fs.readFileSync(path, "utf-8");
  const errors: jsonc.ParseError[] = [];
  const parsed = jsonc.parse(raw, errors);
  if (errors.length > 0) {
    console.warn(`[config-sync] Failed to parse ${path}:`, errors);
    return null;
  }
  return parsed as ExecutorFileConfig;
};

// ---------------------------------------------------------------------------
// Sync from config → DB
// ---------------------------------------------------------------------------

const addSourceFromConfig = (
  executor: LocalExecutor,
  targetScope: ScopeId,
  source: SourceConfig,
): Effect.Effect<void, unknown> => {
  return Match.value(source).pipe(
    Match.when({ kind: "openapi" }, (s) =>
      executor.openapi
        .addSpec({
          spec: s.spec,
          scope: targetScope,
          baseUrl: s.baseUrl,
          namespace: s.namespace,
          headers: translateHeaders(s.headers),
          credentialTargetScope: targetScope,
        })
        .pipe(Effect.asVoid),
    ),
    Match.when({ kind: "graphql" }, (s) =>
      executor.graphql
        .addSource({
          endpoint: s.endpoint,
          scope: targetScope,
          namespace: s.namespace,
          headers: translateHeaders(s.headers) as Record<string, string> | undefined,
          credentialTargetScope: targetScope,
        })
        .pipe(Effect.asVoid),
    ),
    Match.when({ kind: "mcp" }, (s) => {
      if (s.transport === "stdio") {
        return executor.mcp
          .addSource({
            transport: "stdio",
            scope: targetScope,
            name: s.name,
            command: s.command,
            args: s.args ? [...s.args] : undefined,
            env: s.env,
            cwd: s.cwd,
            namespace: s.namespace,
          })
          .pipe(Effect.asVoid);
      }
      return executor.mcp
        .addSource({
          transport: "remote",
          scope: targetScope,
          name: s.name,
          endpoint: s.endpoint,
          remoteTransport: s.remoteTransport,
          queryParams: s.queryParams,
          headers: s.headers,
          namespace: s.namespace,
          auth: translateMcpAuth(s.auth),
          credentialTargetScope: targetScope,
        })
        .pipe(Effect.asVoid);
    }),
    Match.exhaustive,
  );
};

/**
 * Read executor.jsonc and replay all sources into the executor.
 * Each source is added independently — if one fails, the rest still load.
 */
export const syncFromConfig = (input: {
  readonly executor: LocalExecutor;
  readonly configPath: string;
  readonly targetScope: ScopeId;
}): Effect.Effect<void> =>
  Effect.gen(function* () {
    const { executor, configPath, targetScope } = input;
    const config = loadConfigSync(configPath);
    if (!config?.sources?.length) {
      console.log(`[config-sync] ${configPath} missing or empty, skipping`);
      return;
    }

    console.log(`[config-sync] syncing ${config.sources.length} source(s) from ${configPath}`);

    const results = yield* Effect.forEach(
      config.sources,
      (source) =>
        addSourceFromConfig(executor, targetScope, source).pipe(
          Effect.map(() => true as const),
          Effect.catchCause((cause) => {
            const ns =
              "namespace" in source ? source.namespace : "name" in source ? source.name : "unknown";
            const squashed = Cause.squash(cause);
            const message =
              squashed && typeof squashed === "object" && "message" in squashed
                ? String((squashed as { message: unknown }).message)
                : Cause.pretty(cause);
            console.warn(`[config-sync] Failed to load source "${ns}": ${message}`);
            return Effect.succeed(false as const);
          }),
        ),
      // Serial — bun:sqlite serializes transactions on a single connection,
      // so concurrent addSpec calls race on BEGIN.
      { concurrency: 1 },
    );

    const ok = results.filter(Boolean).length;
    console.log(`[config-sync] ${ok}/${results.length} source(s) synced`);
  });