import {
  getConfigStore,
  type ConfigSource,
} from "../config-store.js";
import { ensureObject, readString, updateString } from "../../config.js";

export type DashboardModelOption = {
  value: string;
  label: string;
};

export type DashboardModelsResponse = {
  defaultModel: string;
  options: DashboardModelOption[];
};

export type DashboardModelsSaveRequest = {
  models: {
    defaultModel: string;
  };
};

export class ValidationError extends Error {
  statusCode = 400 as const;
  constructor(message: string) {
    super(message);
    this.name = "ValidationError";
  }
}

function validateDefaultModel(args: { defaultModel: string; allowed: Set<string> }) {
  if (typeof args.defaultModel !== "string") {
    throw new ValidationError("Invalid payload.");
  }

  const defaultModel = args.defaultModel.trim();
  if (!defaultModel) return;

  const parts = defaultModel.split("/");
  if (parts.length !== 2) {
    throw new ValidationError(`Invalid defaultModel: "${args.defaultModel}". Expected "provider/model".`);
  }

  const providerId = parts[0] ?? "";
  const modelId = parts[1] ?? "";
  const idPattern = /^[A-Za-z0-9_.-]+$/;
  if (!idPattern.test(providerId) || !idPattern.test(modelId)) {
    throw new ValidationError(`Invalid defaultModel: "${args.defaultModel}". Expected "provider/model".`);
  }

  if (!args.allowed.has(defaultModel)) {
    throw new ValidationError(`Invalid defaultModel: "${args.defaultModel}" is not in the configured model list.`);
  }
}

export function readModelsResponse(args: ConfigSource): DashboardModelsResponse {
  const root = getConfigStore(args).read();
  const agents = ensureObject(root.agents);
  const defaults = ensureObject(agents.defaults);
  const defaultModel = readString(ensureObject(defaults.model).primary);
  const providersRoot = ensureObject(ensureObject(root.models).providers);

  const options = Object.entries(providersRoot).flatMap(([providerId, providerValue]) => {
    const provider = ensureObject(providerValue);
    const rawModels = Array.isArray(provider.models) ? provider.models : [];
    return rawModels.flatMap((rawModel) => {
      const model = ensureObject(rawModel);
      const id = readString(model.id);
      if (!id) {
        return [];
      }
      const name = readString(model.name) || id;
      return [
        {
          value: `${providerId}/${id}`,
          label: `${providerId} / ${name}`,
        },
      ];
    });
  });

  return {
    defaultModel,
    options,
  };
}

export function saveModelsRequest(args: ConfigSource & { body: DashboardModelsSaveRequest }) {
  const configStore = getConfigStore(args);
  const root = configStore.read();
  const current = readModelsResponse({ configStore });
  const allowed = new Set(current.options.map((option) => option.value));
  validateDefaultModel({ defaultModel: args.body.models.defaultModel, allowed });

  updateString(root, ["agents", "defaults", "model", "primary"], args.body.models.defaultModel);

  configStore.write(root);
}