import type {
  DataDb,
  GraphDb,
  ModelProvider,
  ModelsMode,
  OcrMode,
  PluginChoice,
  ServicesRuntime,
  VectorDb,
} from "../types.js";

export interface InitFlagOverrides {
  defaults?: boolean;
  vectorDb?: VectorDb;
  dataDb?: DataDb;
  graphDb?: GraphDb;
  ocrMode?: OcrMode;
  servicesRuntime?: ServicesRuntime;
  startServices?: boolean;

  modelsMode?: ModelsMode;
  llmSmallProvider?: ModelProvider;
  llmLargeProvider?: ModelProvider;
  embeddingsProvider?: Exclude<ModelProvider, "anthropic" | "deepseek">;
  llmSmall?: string;
  llmLarge?: string;
  embeddingModel?: string;
  embeddingDimensions?: number;

  ollamaHost?: string;
  ollamaPort?: number;
  ollamaSmall?: string;
  ollamaLarge?: string;
  ollamaEmbeddings?: string;

  gcpCredentials?: string;
  gcpProject?: string;
  gcpSmall?: string;
  gcpLarge?: string;
  gcpEmbedding?: string;

  azureEndpoint?: string;
  azureApiVersion?: string;
  azureKey?: string;
  azureSmall?: string;
  azureLarge?: string;
  azureEmbeddingEndpoint?: string;
  azureEmbeddingKey?: string;
  azureEmbedding?: string;

  openaiApiKey?: string;
  openaiBaseUrl?: string;
  openaiSmall?: string;
  openaiLarge?: string;
  openaiEmbedding?: string;

  anthropicApiKey?: string;
  anthropicSmall?: string;
  anthropicLarge?: string;

  deepseekApiKey?: string;
  deepseekSmall?: string;
  deepseekLarge?: string;

  awsRegion?: string;
  awsAccessKeyId?: string;
  awsSecretAccessKey?: string;
  awsSessionToken?: string;
  bedrockSmall?: string;
  bedrockLarge?: string;
  bedrockEmbedding?: string;

  redisHost?: string;
  redisPort?: number;
  postgresHost?: string;
  postgresPort?: number;
  postgresUsername?: string;
  postgresPassword?: string;
  postgresSystemDb?: string;
  postgresMaintenanceDb?: string;
  neo4jHost?: string;
  neo4jPort?: number;
  neo4jUsername?: string;
  neo4jPassword?: string;
  milvusDeployment?: "local" | "managed";
  milvusHost?: string;
  milvusPort?: number;
  milvusUri?: string;
  milvusToken?: string;
  mongoHost?: string;
  mongoPort?: number;
  mongoUsername?: string;
  mongoPassword?: string;

  brainpatToken?: string;
  plugins?: PluginChoice[];
  noPlugins?: boolean;
}

const VECTOR_DBS = new Set<VectorDb>(["postgresql", "milvus"]);
const DATA_DBS = new Set<DataDb>(["postgresql", "mongo"]);
const GRAPH_DBS = new Set<GraphDb>(["networkx", "neo4j"]);
const OCR_MODES = new Set<OcrMode>(["docparser", "docling"]);
const RUNTIMES = new Set<ServicesRuntime>(["docker", "manual"]);
const MODELS_MODES = new Set<ModelsMode>(["local", "remote"]);
const LLM_PROVIDERS = new Set<ModelProvider>([
  "ollama",
  "openai",
  "anthropic",
  "deepseek",
  "azure",
  "gcp_vertex",
  "amazon_bedrock",
]);
const EMBEDDING_PROVIDERS = new Set<Exclude<ModelProvider, "anthropic" | "deepseek">>([
  "ollama",
  "openai",
  "azure",
  "gcp_vertex",
  "amazon_bedrock",
]);

function splitFlag(arg: string): { name: string; inline?: string } {
  const eq = arg.indexOf("=");
  if (eq === -1) return { name: arg };
  return { name: arg.slice(0, eq), inline: arg.slice(eq + 1) };
}

function takeValue(
  inline: string | undefined,
  args: string[],
  flag: string,
): { ok: true; value: string } | { ok: false; error: string } {
  if (inline !== undefined) {
    if (inline.length === 0) {
      return { ok: false, error: `${flag} requires a value` };
    }
    return { ok: true, value: inline };
  }
  const next = args.shift();
  if (next === undefined || next.startsWith("-")) {
    if (next !== undefined) args.unshift(next);
    return { ok: false, error: `${flag} requires a value` };
  }
  return { ok: true, value: next };
}

function parsePort(
  raw: string,
  flag: string,
): { ok: true; value: number } | { ok: false; error: string } {
  const n = Number(raw);
  if (!Number.isInteger(n) || n <= 0 || n > 65535) {
    return { ok: false, error: `${flag} must be an integer port 1-65535` };
  }
  return { ok: true, value: n };
}

function parsePositiveInt(
  raw: string,
  flag: string,
): { ok: true; value: number } | { ok: false; error: string } {
  const n = Number(raw);
  if (!Number.isInteger(n) || n <= 0) {
    return { ok: false, error: `${flag} must be a positive integer` };
  }
  return { ok: true, value: n };
}

function parsePluginSpec(raw: string): PluginChoice {
  const at = raw.lastIndexOf("@");
  if (at > 0) {
    return {
      name: raw.slice(0, at),
      source: "registry",
      version: raw.slice(at + 1),
    };
  }
  return { name: raw, source: "registry" };
}

/** True when any wizard-config flag is present (skips “use defaults?”). */
export function hasConfigOverrides(flags: InitFlagOverrides): boolean {
  const {
    defaults: _defaults,
    startServices: _start,
    ...rest
  } = flags;
  return Object.values(rest).some((v) => v !== undefined);
}

export type ApplyInitFlagResult =
  | { kind: "applied" }
  | { kind: "unknown" }
  | { kind: "error"; error: string };

/** Apply a single init flag. Mutates `flags` and may shift `args` for the value. */
export function tryApplyInitFlag(
  raw: string,
  args: string[],
  flags: InitFlagOverrides,
): ApplyInitFlagResult {
  if (!raw.startsWith("-")) return { kind: "unknown" };

  const { name, inline } = splitFlag(raw);

  const setString = (key: keyof InitFlagOverrides, flagName: string): ApplyInitFlagResult => {
    const taken = takeValue(inline, args, flagName);
    if (!taken.ok) return { kind: "error", error: taken.error };
    (flags as Record<string, unknown>)[key] = taken.value;
    return { kind: "applied" };
  };

  const setPort = (key: keyof InitFlagOverrides, flagName: string): ApplyInitFlagResult => {
    const taken = takeValue(inline, args, flagName);
    if (!taken.ok) return { kind: "error", error: taken.error };
    const port = parsePort(taken.value, flagName);
    if (!port.ok) return { kind: "error", error: port.error };
    (flags as Record<string, unknown>)[key] = port.value;
    return { kind: "applied" };
  };

  switch (name) {
    case "--defaults":
      flags.defaults = true;
      return { kind: "applied" };
    case "--vector-db": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const v = taken.value.toLowerCase() as VectorDb;
      if (!VECTOR_DBS.has(v)) {
        return {
          kind: "error",
          error: `Invalid --vector-db "${taken.value}". Use postgresql or milvus.`,
        };
      }
      flags.vectorDb = v;
      return { kind: "applied" };
    }
    case "--data-db": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const v = taken.value.toLowerCase() as DataDb;
      if (!DATA_DBS.has(v)) {
        return {
          kind: "error",
          error: `Invalid --data-db "${taken.value}". Use postgresql or mongo.`,
        };
      }
      flags.dataDb = v;
      return { kind: "applied" };
    }
    case "--graph-db": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const v = taken.value.toLowerCase() as GraphDb;
      if (!GRAPH_DBS.has(v)) {
        return {
          kind: "error",
          error: `Invalid --graph-db "${taken.value}". Use networkx or neo4j.`,
        };
      }
      flags.graphDb = v;
      return { kind: "applied" };
    }
    case "--ocr-mode": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const v = taken.value.toLowerCase() as OcrMode;
      if (!OCR_MODES.has(v)) {
        return {
          kind: "error",
          error: `Invalid --ocr-mode "${taken.value}". Use docparser or docling.`,
        };
      }
      flags.ocrMode = v;
      return { kind: "applied" };
    }
    case "--services-runtime": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const v = taken.value.toLowerCase() as ServicesRuntime;
      if (!RUNTIMES.has(v)) {
        return {
          kind: "error",
          error: `Invalid --services-runtime "${taken.value}". Use docker or manual.`,
        };
      }
      flags.servicesRuntime = v;
      return { kind: "applied" };
    }
    case "--start-services":
      flags.startServices = true;
      return { kind: "applied" };
    case "--no-start-services":
      flags.startServices = false;
      return { kind: "applied" };
    case "--models-mode": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const v = taken.value.toLowerCase() as ModelsMode;
      if (!MODELS_MODES.has(v)) {
        return {
          kind: "error",
          error: `Invalid --models-mode "${taken.value}". Use local or remote.`,
        };
      }
      flags.modelsMode = v;
      return { kind: "applied" };
    }
    case "--llm-small-provider": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const v = taken.value.toLowerCase() as ModelProvider;
      if (!LLM_PROVIDERS.has(v)) {
        return {
          kind: "error",
          error: `Invalid --llm-small-provider "${taken.value}".`,
        };
      }
      flags.llmSmallProvider = v;
      return { kind: "applied" };
    }
    case "--llm-large-provider": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const v = taken.value.toLowerCase() as ModelProvider;
      if (!LLM_PROVIDERS.has(v)) {
        return {
          kind: "error",
          error: `Invalid --llm-large-provider "${taken.value}".`,
        };
      }
      flags.llmLargeProvider = v;
      return { kind: "applied" };
    }
    case "--embeddings-provider": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const v = taken.value.toLowerCase() as Exclude<
        ModelProvider,
        "anthropic" | "deepseek"
      >;
      if (!EMBEDDING_PROVIDERS.has(v)) {
        return {
          kind: "error",
          error: `Invalid --embeddings-provider "${taken.value}".`,
        };
      }
      flags.embeddingsProvider = v;
      return { kind: "applied" };
    }
    case "--llm-small":
      return setString("llmSmall", name);
    case "--llm-large":
      return setString("llmLarge", name);
    case "--embedding-model":
      return setString("embeddingModel", name);
    case "--embedding-dimensions": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const n = parsePositiveInt(taken.value, name);
      if (!n.ok) return { kind: "error", error: n.error };
      flags.embeddingDimensions = n.value;
      return { kind: "applied" };
    }
    case "--ollama-host":
      return setString("ollamaHost", name);
    case "--ollama-port":
      return setPort("ollamaPort", name);
    case "--ollama-small":
      return setString("ollamaSmall", name);
    case "--ollama-large":
      return setString("ollamaLarge", name);
    case "--ollama-embeddings":
      return setString("ollamaEmbeddings", name);
    case "--gcp-credentials":
      return setString("gcpCredentials", name);
    case "--gcp-project":
      return setString("gcpProject", name);
    case "--gcp-small":
      return setString("gcpSmall", name);
    case "--gcp-large":
      return setString("gcpLarge", name);
    case "--gcp-embedding":
      return setString("gcpEmbedding", name);
    case "--azure-endpoint":
      return setString("azureEndpoint", name);
    case "--azure-api-version":
      return setString("azureApiVersion", name);
    case "--azure-key":
      return setString("azureKey", name);
    case "--azure-small":
      return setString("azureSmall", name);
    case "--azure-large":
      return setString("azureLarge", name);
    case "--azure-embedding-endpoint":
      return setString("azureEmbeddingEndpoint", name);
    case "--azure-embedding-key":
      return setString("azureEmbeddingKey", name);
    case "--azure-embedding":
      return setString("azureEmbedding", name);
    case "--openai-api-key":
      return setString("openaiApiKey", name);
    case "--openai-base-url":
      return setString("openaiBaseUrl", name);
    case "--openai-small":
      return setString("openaiSmall", name);
    case "--openai-large":
      return setString("openaiLarge", name);
    case "--openai-embedding":
      return setString("openaiEmbedding", name);
    case "--anthropic-api-key":
      return setString("anthropicApiKey", name);
    case "--anthropic-small":
      return setString("anthropicSmall", name);
    case "--anthropic-large":
      return setString("anthropicLarge", name);
    case "--deepseek-api-key":
      return setString("deepseekApiKey", name);
    case "--deepseek-small":
      return setString("deepseekSmall", name);
    case "--deepseek-large":
      return setString("deepseekLarge", name);
    case "--aws-region":
      return setString("awsRegion", name);
    case "--aws-access-key-id":
      return setString("awsAccessKeyId", name);
    case "--aws-secret-access-key":
      return setString("awsSecretAccessKey", name);
    case "--aws-session-token":
      return setString("awsSessionToken", name);
    case "--bedrock-small":
      return setString("bedrockSmall", name);
    case "--bedrock-large":
      return setString("bedrockLarge", name);
    case "--bedrock-embedding":
      return setString("bedrockEmbedding", name);
    case "--redis-host":
      return setString("redisHost", name);
    case "--redis-port":
      return setPort("redisPort", name);
    case "--postgres-host":
      return setString("postgresHost", name);
    case "--postgres-port":
      return setPort("postgresPort", name);
    case "--postgres-username":
      return setString("postgresUsername", name);
    case "--postgres-password":
      return setString("postgresPassword", name);
    case "--postgres-system-db":
      return setString("postgresSystemDb", name);
    case "--postgres-maintenance-db":
      return setString("postgresMaintenanceDb", name);
    case "--neo4j-host":
      return setString("neo4jHost", name);
    case "--neo4j-port":
      return setPort("neo4jPort", name);
    case "--neo4j-username":
      return setString("neo4jUsername", name);
    case "--neo4j-password":
      return setString("neo4jPassword", name);
    case "--milvus-deployment": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      const v = taken.value.toLowerCase();
      if (v !== "local" && v !== "managed") {
        return {
          kind: "error",
          error: `Invalid --milvus-deployment "${taken.value}". Use local or managed.`,
        };
      }
      flags.milvusDeployment = v;
      return { kind: "applied" };
    }
    case "--milvus-host":
      return setString("milvusHost", name);
    case "--milvus-port":
      return setPort("milvusPort", name);
    case "--milvus-uri":
      return setString("milvusUri", name);
    case "--milvus-token":
      return setString("milvusToken", name);
    case "--mongo-host":
      return setString("mongoHost", name);
    case "--mongo-port":
      return setPort("mongoPort", name);
    case "--mongo-username":
      return setString("mongoUsername", name);
    case "--mongo-password":
      return setString("mongoPassword", name);
    case "--brainpat-token":
      return setString("brainpatToken", name);
    case "--plugin": {
      const taken = takeValue(inline, args, name);
      if (!taken.ok) return { kind: "error", error: taken.error };
      if (!flags.plugins) flags.plugins = [];
      flags.plugins.push(parsePluginSpec(taken.value));
      return { kind: "applied" };
    }
    case "--no-plugins":
      flags.noPlugins = true;
      return { kind: "applied" };
    default:
      return { kind: "unknown" };
  }
}