export const ASSISTANT_PROVIDER_EXECUTION_CONTRACT_SCHEMA_VERSION =
  "assistant_provider_execution_contract_v1" as const;

export interface ResolveAssistantProviderExecutionInput {
  llmProvider?: unknown;
  useMock?: unknown;
  baseUrl?: unknown;
  llmPreDecomposeReason?: unknown;
}

export interface AssistantProviderExecutionContract {
  schema_version: typeof ASSISTANT_PROVIDER_EXECUTION_CONTRACT_SCHEMA_VERSION;
  policy_owner: "assistantProviderExecutionPolicy";
  provider_mode: "mock" | "openai" | "local" | "unknown";
  normalized_provider: "openai" | "local" | null;
  use_mock: boolean;
  base_url_configured: boolean;
  llm_runtime_unavailable_detected: boolean;
  living_mode_forced_deep: boolean;
  living_mode_forced_reason: string | null;
  reason_codes: string[];
}

export interface AssistantProviderExecutionPolicy {
  normalizeProvider: (value: unknown) => "openai" | "local" | null;
  detectLlmRuntimeUnavailable: (reason: unknown) => boolean;
  resolveProviderExecutionState: (
    input: ResolveAssistantProviderExecutionInput
  ) => AssistantProviderExecutionContract;
}

export function createAssistantProviderExecutionPolicy(): AssistantProviderExecutionPolicy {
  function normalizeProvider(value: unknown): "openai" | "local" | null {
    return value === "local" ? "local" : value === "openai" ? "openai" : null;
  }

  function detectLlmRuntimeUnavailable(reason: unknown): boolean {
    const source = String(reason ?? "").trim();
    if (!source) {
      return false;
    }
    return /(?:openai\s+api\s+key\s+is\s+missing|api\s+key\s+is\s+missing|missing\s+api\s+key|authentication|unauthoriz(?:ed|ation)|401\b)/iu.test(
      source
    );
  }

  function resolveProviderExecutionState(
    input: ResolveAssistantProviderExecutionInput
  ): AssistantProviderExecutionContract {
    const normalizedProvider = normalizeProvider(input?.llmProvider);
    const useMock = Boolean(input?.useMock);
    const baseUrlConfigured = String(input?.baseUrl ?? "").trim().length > 0;
    const llmRuntimeUnavailableDetected = detectLlmRuntimeUnavailable(input?.llmPreDecomposeReason);

    const reasonCodes: string[] = [];
    if (useMock) {
      reasonCodes.push("mock_mode_enabled");
    }
    if (normalizedProvider === "local") {
      reasonCodes.push("provider_local");
    } else if (normalizedProvider === "openai") {
      reasonCodes.push("provider_openai");
    } else {
      reasonCodes.push("provider_unknown");
    }
    if (baseUrlConfigured) {
      reasonCodes.push("base_url_configured");
    }
    if (llmRuntimeUnavailableDetected) {
      reasonCodes.push("llm_runtime_unavailable");
    }

    return {
      schema_version: ASSISTANT_PROVIDER_EXECUTION_CONTRACT_SCHEMA_VERSION,
      policy_owner: "assistantProviderExecutionPolicy",
      provider_mode: useMock ? "mock" : normalizedProvider ?? "unknown",
      normalized_provider: normalizedProvider,
      use_mock: useMock,
      base_url_configured: baseUrlConfigured,
      llm_runtime_unavailable_detected: llmRuntimeUnavailableDetected,
      living_mode_forced_deep: useMock,
      living_mode_forced_reason: useMock ? "mock_mode_keeps_deep_pipeline" : null,
      reason_codes: reasonCodes
    };
  }

  return {
    normalizeProvider,
    detectLlmRuntimeUnavailable,
    resolveProviderExecutionState
  };
}