/**
 * Claude auth presence detection.
 *
 * THREE values, not two. `unknown` means a source could not be READ (denied keychain,
 * permission error, corrupt JSON) — treating that as `absent` would silently flip a
 * subscriber into proxy mode, which is the failure this whole unit exists to prevent
 * (devlog/_plan/260726_claude_auth_auto/001 F1). The resolver maps unknown to the
 * historical default (subscription), never to proxy.
 *
 * IO is injectable so every source is testable without touching the real home
 * directory, keychain, or environment.
 */
import { existsSync, readFileSync } from "node:fs";
import { homedir } from "node:os";
import { join } from "node:path";
import { claudeKeychainReader } from "../oauth/claude-keychain-read";

export type AuthPresence = "present" | "absent" | "unknown";

export type AuthSourceId =
  | "claude-json-oauth"        // S1: <config-dir>/../.claude.json oauthAccount
  | "claude-credentials-file"  // S2: <config-dir>/.credentials.json
  | "macos-keychain"           // S3: security find-generic-password (metadata only)
  | "exported-env";            // S5: ANTHROPIC_API_KEY / a USER's ANTHROPIC_AUTH_TOKEN

// NOTE: there is deliberately no "opencodex anthropic OAuth" source. That is a
// PROVIDER credential in opencodex's own store which the Claude CLI never consumes,
// so it is not evidence the client can authenticate natively (audit 002 §5).

/**
 * The one opencodex-owned dummy token. Exported so the CLI, the system-env writer and
 * the tests all compare against the same literal — a second copy is how the marker
 * feedback loop (002 §1) sneaks back in.
 */
export const PROXY_MARKER = "opencodex-proxy";

/**
 * The macOS Keychain source, resolved once at an asynchronous boundary and handed to
 * {@link defaultAuthDetectDeps}. Detection itself stays synchronous, but the lookup behind it must
 * not: a synchronous `security` child can only be bounded by killing it, and killing one that is
 * waiting on an unlock prompt crashes `securityd` and re-locks the keychain (#8161). The shared
 * reader runs it without ever signalling the child, under the same single slot and backoff as the
 * credential read, and answers `absent` on a non-darwin host.
 *
 * A manual `claudeCode.authMode` ("proxy" or "subscription") never consults detection, so the
 * probe is skipped there: a pinned user pays no wait and sees no unlock prompt for a discarded
 * answer. The keychain source then reads `unknown`, which is never `absent`.
 */
export function resolveClaudeKeychainPresence(authMode?: string): Promise<AuthPresence> {
  if (authMode === "proxy" || authMode === "subscription") {
    return Promise.resolve(process.platform === "darwin" ? "unknown" : "absent");
  }
  return claudeKeychainReader.probe();
}

export interface AuthSourceResult {
  source: AuthSourceId;
  presence: AuthPresence;
  /** One short, credential-free line. Never contains token material. */
  detail?: string;
}

export interface AuthDetectDeps {
  /** Parsed ~/.claude.json; undefined when missing; throws on corrupt/unreadable. */
  readClaudeJson(): Record<string, unknown> | undefined;
  /** Whether <config-dir>/.credentials.json exists; throws on read error. */
  credentialsFileExists(): boolean;
  /** present/absent/unknown for the macOS keychain, already resolved; absent on non-Darwin. */
  keychainProbe(): AuthPresence;
  /**
   * The environment to inspect for S5. Callers pass the SAME base env the launch will
   * use, so detection and the spawned process can never disagree. Injection is typed
   * to exclude this key (see `detectClaudeAuth` callers) so a test fake cannot
   * silently replace the binding.
   */
  env(): NodeJS.ProcessEnv;
  /**
   * Token values opencodex itself put into the environment. `system-env.ts` exports the
   * configured admission key as `ANTHROPIC_AUTH_TOKEN`, so without this the detector
   * reads OUR OWN output back as proof the user can authenticate natively — the same
   * feedback loop the `PROXY_MARKER` guard closes, one variable over.
   */
  ownTokens?: readonly string[];
}

export interface AuthDetectResult {
  /** present if ANY source is present; unknown if none present but ANY unknown. */
  presence: AuthPresence;
  /** The source that proved presence, when any — feeds the GUI reason badge. */
  foundBy?: AuthSourceId;
  sources: AuthSourceResult[];
  /**
   * True when the inspected env carries OUR OWN dummy marker. It must never count as
   * user auth, and a subscription resolution strips it before launch (002 §1).
   */
  staleProxyMarker: boolean;
}

/** Claude Code config dir: `CLAUDE_CONFIG_DIR` override, else `~/.claude`. */
export function claudeConfigDir(env: NodeJS.ProcessEnv = process.env): string {
  const explicit = env.CLAUDE_CONFIG_DIR?.trim();
  return explicit ? explicit : join(homeDir(env), ".claude");
}

/**
 * `os.homedir()` reads the OS user database and ignores a reassigned `HOME`, which
 * makes an isolated-profile probe silently read the real user's files. Prefer the
 * environment the caller handed us; fall back to the OS value.
 */
function homeDir(env: NodeJS.ProcessEnv): string {
  const fromEnv = env.HOME?.trim() || env.USERPROFILE?.trim();
  return fromEnv ? fromEnv : homedir();
}

function detectClaudeJson(deps: AuthDetectDeps): AuthSourceResult {
  try {
    const parsed = deps.readClaudeJson();
    if (parsed === undefined) return { source: "claude-json-oauth", presence: "absent" };
    const account = parsed.oauthAccount;
    if (account && typeof account === "object" && !Array.isArray(account)) {
      const email = (account as Record<string, unknown>).emailAddress;
      if (typeof email === "string" && email.trim().length > 0) {
        // Never echo the address itself — the detail line is UI copy, not a credential.
        return { source: "claude-json-oauth", presence: "present", detail: "oauthAccount" };
      }
    }
    return { source: "claude-json-oauth", presence: "absent" };
  } catch {
    // Corrupt or unreadable is NOT absent (F1).
    return { source: "claude-json-oauth", presence: "unknown", detail: "unreadable" };
  }
}

function detectCredentialsFile(deps: AuthDetectDeps): AuthSourceResult {
  try {
    return {
      source: "claude-credentials-file",
      presence: deps.credentialsFileExists() ? "present" : "absent",
    };
  } catch {
    return { source: "claude-credentials-file", presence: "unknown", detail: "unreadable" };
  }
}

function detectKeychain(deps: AuthDetectDeps): AuthSourceResult {
  try {
    return { source: "macos-keychain", presence: deps.keychainProbe() };
  } catch {
    return { source: "macos-keychain", presence: "unknown", detail: "probe failed" };
  }
}

function detectExportedEnv(deps: AuthDetectDeps): AuthSourceResult {
  try {
    const env = deps.env();
    const isOwn = (value: string): boolean =>
      value === PROXY_MARKER || (deps.ownTokens ?? []).includes(value);
    const apiKey = env.ANTHROPIC_API_KEY?.trim();
    if (apiKey && !isOwn(apiKey)) {
      return { source: "exported-env", presence: "present", detail: "ANTHROPIC_API_KEY" };
    }
    const token = env.ANTHROPIC_AUTH_TOKEN?.trim();
    // Our own dummy is opencodex state, never user auth: counting it would make a
    // proxy-mode launch look authenticated on the NEXT launch (002 §1). The configured
    // admission key is opencodex state for exactly the same reason — the system-env
    // writer exports it into this very variable.
    if (token && !isOwn(token)) {
      return { source: "exported-env", presence: "present", detail: "ANTHROPIC_AUTH_TOKEN" };
    }
    return { source: "exported-env", presence: "absent" };
  } catch {
    return { source: "exported-env", presence: "unknown" };
  }
}

export function detectClaudeAuth(deps: AuthDetectDeps): AuthDetectResult {
  const sources = [
    detectClaudeJson(deps),
    detectCredentialsFile(deps),
    detectKeychain(deps),
    detectExportedEnv(deps),
  ];
  let staleProxyMarker = false;
  try {
    staleProxyMarker = deps.env().ANTHROPIC_AUTH_TOKEN?.trim() === PROXY_MARKER;
  } catch {
    staleProxyMarker = false;
  }

  const present = sources.find(source => source.presence === "present");
  if (present) return { presence: "present", foundBy: present.source, sources, staleProxyMarker };
  if (sources.some(source => source.presence === "unknown")) {
    return { presence: "unknown", sources, staleProxyMarker };
  }
  return { presence: "absent", sources, staleProxyMarker };
}

/**
 * Real IO. The Keychain source is the caller's pre-resolved {@link resolveClaudeKeychainPresence}
 * result. A caller that did not resolve one gets `unknown` on macOS, which the resolver maps to
 * subscription; it is never read as `absent`.
 */
export function defaultAuthDetectDeps(
  env: NodeJS.ProcessEnv = process.env,
  ownTokens: readonly string[] = [],
  keychainPresence: AuthPresence = process.platform === "darwin" ? "unknown" : "absent",
): AuthDetectDeps {
  const configDir = claudeConfigDir(env);
  return {
    readClaudeJson() {
      // Sibling of the config dir when CLAUDE_CONFIG_DIR is set, else ~/.claude.json.
      const path = env.CLAUDE_CONFIG_DIR?.trim()
        ? join(configDir, "..", ".claude.json")
        : join(homeDir(env), ".claude.json");
      if (!existsSync(path)) return undefined;
      // A parse failure propagates so the caller records `unknown`, not `absent`.
      return JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
    },
    credentialsFileExists() {
      return existsSync(join(configDir, ".credentials.json"));
    },
    keychainProbe: () => keychainPresence,
    env: () => env,
    ownTokens,
  };
}

/**
 * The token values opencodex itself exports. Configured admission keys land in
 * `ANTHROPIC_AUTH_TOKEN` (see `system-env.ts`), so detection must not read them back
 * as user auth.
 */
export function ownAdmissionTokens(config: { apiKeys?: Array<{ key: string }> }): string[] {
  return (config.apiKeys ?? []).map(entry => entry.key).filter(key => key.length > 0);
}
