import type { NotebookLanguage } from './notebook'

// Renderer-safe wire shapes for the notebook Runtime Registry (managed + external environments).
// RuntimeEnablement owns global admission while NotebookRuntimeBindings own each Session's selected
// targets. The coarse pythonReady/rReady booleans (shared/notebook-env.ts) do not capture BYO.

// Where a language's interpreter comes from: an app-owned micromamba env, or the user's own install.
export type RuntimeSource = 'managed' | 'external'

// The ONE mapping from who owns an env to which tool reads/writes its packages (the `via` in
// package-operation policy): app-owned conda envs (managed OR agent-created, both under the app
// runtime root) go through the bundled micromamba; the user's own envs are handled by their own
// interpreter's pip (Python) or their own R library (R) — never the bundled micromamba against a
// foreign env. Shared by package writes and the Settings package listing so they cannot drift.
export const packageToolFor = (
  language: NotebookLanguage,
  appOwned: boolean
): 'micromamba' | 'pip' | 'r-library' =>
  appOwned ? 'micromamba' : language === 'r' ? 'r-library' : 'pip'

// v4 environment discovery (Settings cards). Where an interpreter came from — also gates the agent
// remove-guard: only 'agent-created' envs may be removed by the agent.
export type EnvProvenance = 'app-managed' | 'user-own' | 'agent-created'

// One detected interpreter. `envId` (its real path) is the stable identity used to persist the
// per-env enabled/disabled choice across re-detection.
export type DiscoveredInterpreter = {
  language: NotebookLanguage
  provenance: EnvProvenance
  envId: string
  interpreterPath: string
  label: string
  version?: string
  runnable: boolean
  condaEnv?: string
  detail?: string
  // Advisory discovery only; never persisted as consent. Missing means detection was unavailable.
  personalRLibraries?: string[]
}

// One installed package in a discovered environment, surfaced by the Settings "Packages" dialog.
// `build`/`channel` are present only for conda-tracked entries (a micromamba listing); pip and CRAN
// listings carry name + version only.
export type EnvPackage = {
  name: string
  version: string
  build?: string
  channel?: string
}

// The v4 per-language enablement state, keyed by `envId` (the interpreter's real path). `enabled` is
// an EXPLICIT override map — a present entry wins over the provenance default (see isEnvEnabled), an
// absent one falls back to it, so re-detection and new envs keep working without a migration.
// `installAuthorized` is the SEPARATE high-risk opt-in that lets Open-Science write packages into an
// external env (default OFF; execute-after-enable stays read-only until this is turned on).
export type RuntimeEnablement = {
  enabled: Record<string, boolean>
  installAuthorized: Record<string, boolean>
  // Explicit R library consent. Historical booleans alone never authorize R writes.
  installLibraries?: Record<string, string>
}

// How many live sessions are bound to a runtime, split by kernel state, so the Settings disable
// affordance can warn about impact before revoking. running = a cell is executing on it; idle = its
// kernel is live but not running; dormant = bound but no live kernel (nothing to drain/close).
export type RuntimeUsage = {
  running: number
  idle: number
  dormant: number
}

// Lifecycle status of a session binding. 'active' = usable now; 'revoking' = a disable is draining
// the in-flight lease before tearing the kernel down; 'unavailable' = the bound runtime can no longer
// back a run and the agent must switch (see reason). No silent fallback: an unavailable binding makes
// execute/install reject in the main process rather than quietly running a different interpreter.
export type RuntimeBindingStatus = 'active' | 'revoking' | 'unavailable'

// Why a binding is unavailable. 'disabled' = the runtime was turned off in Settings; 'missing' = its
// interpreter/env was deleted or moved; 'repair-required' = an interrupted env operation left it in an
// unverified state (see notebook-runtime-crash-recovery). Absent while status is active/revoking.
export type RuntimeBindingUnavailableReason = 'disabled' | 'missing' | 'repair-required'

// v4 session runtime binding: the ENABLED runtime a session runs one language on for the whole
// session (one runtime per language per session — no implicit per-call switching). `runtimeId` is the
// discovered env's stable identity (its real path), `source` mirrors the provenance ('managed' =
// app-owned env, 'external' = the user's own interpreter). Surfaced to the agent via notebook_state /
// list_notebook_runtimes so it can see and (re)choose its bindings with notebook_bind/switch_runtime.
export type NotebookRuntimeBinding = {
  language: NotebookLanguage
  runtimeId: string
  source: RuntimeSource
  provenance: EnvProvenance
  interpreterPath: string
  label: string
  version?: string
  // Lifecycle status; absent is treated as 'active' by older readers. reason is set only when status
  // is 'unavailable'. Persisted so a session's binding + why it is unusable survive a restart.
  status?: RuntimeBindingStatus
  reason?: RuntimeBindingUnavailableReason
}

// The session's current per-language bindings (absent = still resolving to the app-managed default).
export type NotebookRuntimeBindings = {
  python?: NotebookRuntimeBinding
  r?: NotebookRuntimeBinding
}

// Stable evidence for the Runtime Environment an operation would use. An absent explicit Runtime
// Binding is represented directly instead of being confused with a managed binding.
export type RuntimeTargetReceipt =
  | {
      language: NotebookLanguage
      selection: 'implicit-default' | 'explicit-binding'
      runtimeSource: RuntimeSource
      environmentName?: string
      runtimeId: string
      label: string
      prefix?: string
    }
  | {
      language: NotebookLanguage
      // Target resolution itself failed or produced no enabled runtime. Do not invent ownership or a
      // canonical identity in that case; later discovery work may attach a more specific typed error.
      selection: 'unresolved'
    }

export type RuntimeBindingOperationResult =
  | {
      bound: NotebookRuntimeBinding
      bindings: NotebookRuntimeBindings
    }
  | {
      ok: false
      // A failed durability confirmation may follow a published binding. Report the actual change.
      bindingChanged: boolean
      error: string
      bindings: NotebookRuntimeBindings
      target: RuntimeTargetReceipt
    }

// One entry in list_notebook_runtimes: an ENABLED runtime (app-managed + user-enabled external, never
// disabled) plus whether it is the session's current binding and whether it can back the kernel loop.
export type NotebookRuntimeListing = NotebookRuntimeBinding & {
  runnable: boolean
  bound: boolean
  detail?: string
}

// Whether a detected env is effective-enabled: an explicit override wins, else the provenance default.
// App-managed AND agent-created envs default ON — both are app-controlled (the agent created the
// latter for its own use, so it must be bindable without a manual enable). Only the USER'S OWN
// interpreters default OFF, requiring explicit opt-in in Settings. Pure so the main-process invariant
// and the UI share one source of truth.
export const isEnvEnabled = (
  env: DiscoveredInterpreter,
  enablement?: RuntimeEnablement
): boolean => {
  const explicit = enablement?.enabled[env.envId]
  return explicit !== undefined ? explicit : env.provenance !== 'user-own'
}