import { basename, dirname, resolve } from "node:path";
import { existsSync } from "node:fs";
import { homedir } from "node:os";
import type { RouteRegistrar } from "../../http/route-registrar";
import type { Recipe } from "../models/types";
import { resolveModelVision } from "@local-studio/contracts/model-capabilities";

/**
 * OpenAI-compatible model info.
 */
interface OpenAIModelInfo {
  id: string;
  object: "model";
  created: number;
  owned_by: string;
  active: boolean;
  max_model_len?: number | null;
  metadata: Record<string, unknown>;
}

/**
 * OpenAI-compatible model list response.
 */
interface OpenAIModelList {
  object: "list";
  data: OpenAIModelInfo[];
}
import { buildModelInfo, discoverModelDirectories } from "./model-browser";
import { notFound } from "../../core/errors";
import { findObservedInferenceProcess } from "../../core/function-observability";
import { parseBooleanFlag } from "../../core/validation";
import { fetchInference } from "../../http/local-fetch";

function isMockInferenceEnabled(): boolean {
  return parseBooleanFlag(process.env["LOCAL_STUDIO_MOCK_INFERENCE"]);
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
}

function recipeMetadata(recipe: Recipe): Record<string, unknown> {
  const metadata = recipe.extra_args?.["metadata"];
  return isRecord(metadata) ? metadata : {};
}

function resolvedRecipeMetadata(recipe: Recipe, modelId: string): Record<string, unknown> {
  const metadata = recipeMetadata(recipe);
  return {
    ...metadata,
    vision: resolveModelVision({
      identifiers: [modelId, recipe.id, recipe.name, recipe.model_path],
      recipeOverride: recipe.vision,
      metadata,
    }),
  };
}

export const registerModelsRoutes: RouteRegistrar = (app, context) => {
  app.get("/v1/models", async (ctx) => {
    const recipes = context.stores.recipeStore.list();
    const current = await findObservedInferenceProcess(context, "models.list");
    let activeModelData: { data?: Array<{ max_model_len?: number }> } | null = null;
    if (current) {
      try {
        const response = await fetchInference(context, "/v1/models", { timeoutMs: 5000 });
        if (response.ok) {
          activeModelData = (await response.json()) as { data?: Array<{ max_model_len?: number }> };
        }
      } catch {
        activeModelData = null;
      }
    }

    const models: OpenAIModelInfo[] = [];
    const now = Math.floor(Date.now() / 1000);
    for (const recipe of recipes) {
      let isActive = false;
      let maxModelLength = recipe.max_model_len;
      if (current) {
        if (current.served_model_name && recipe.served_model_name === current.served_model_name) {
          isActive = true;
        } else if (current.model_path) {
          if (
            recipe.model_path.includes(current.model_path) ||
            current.model_path.includes(recipe.model_path)
          ) {
            isActive = true;
          } else if (basename(current.model_path) === basename(recipe.model_path)) {
            isActive = true;
          }
        }
        if (isActive && activeModelData?.data?.[0]?.max_model_len) {
          maxModelLength = activeModelData.data[0].max_model_len;
        }
      }
      const modelId = recipe.served_model_name ?? recipe.id;
      models.push({
        id: modelId,
        object: "model",
        created: now,
        owned_by: "local-studio",
        active: isActive,
        max_model_len: maxModelLength,
        metadata: resolvedRecipeMetadata(recipe, modelId),
      });
    }

    // Dev / mock-friendly fallback: when there are no recipes configured, still return a model so the UI
    // can render a model selector (and avoid "no models" dead-ends on mobile).
    if (models.length === 0 && (isMockInferenceEnabled() || current)) {
      const inferredId =
        process.env["LOCAL_STUDIO_MOCK_MODEL_ID"]?.trim() ||
        current?.served_model_name ||
        (current?.model_path ? basename(current.model_path) : "") ||
        "mock";
      models.push({
        id: inferredId,
        object: "model",
        created: now,
        owned_by: "local-studio",
        active: true,
        max_model_len: activeModelData?.data?.[0]?.max_model_len ?? 32768,
        metadata: {
          vision: resolveModelVision({ identifiers: [inferredId] }),
        },
      });
    }

    const payload: OpenAIModelList = { object: "list", data: models };
    return ctx.json(payload);
  });

  app.get("/v1/models/:modelId", async (ctx) => {
    const modelId = ctx.req.param("modelId");
    const recipes = context.stores.recipeStore.list();
    let recipe: Recipe | null = null;
    for (const entry of recipes) {
      if (
        (entry.served_model_name && entry.served_model_name === modelId) ||
        entry.id === modelId
      ) {
        recipe = entry;
        break;
      }
    }
    if (!recipe) {
      throw notFound("Model not found");
    }

    const current = await findObservedInferenceProcess(context, "models.detail");
    let isActive = false;
    let maxModelLength = recipe.max_model_len;
    if (
      current &&
      current.model_path &&
      recipe.model_path &&
      current.model_path.includes(recipe.model_path)
    ) {
      isActive = true;
      try {
        const response = await fetchInference(context, "/v1/models", { timeoutMs: 5000 });
        if (response.ok) {
          const data = (await response.json()) as { data?: Array<{ max_model_len?: number }> };
          if (data.data?.[0]?.max_model_len) {
            maxModelLength = data.data[0].max_model_len;
          }
        }
      } catch {
        maxModelLength = recipe.max_model_len;
      }
    }

    const payload: OpenAIModelInfo = {
      id: recipe.served_model_name ?? recipe.id,
      object: "model",
      created: Math.floor(Date.now() / 1000),
      owned_by: "local-studio",
      active: isActive,
      max_model_len: maxModelLength,
      metadata: resolvedRecipeMetadata(recipe, recipe.served_model_name ?? recipe.id),
    };

    return ctx.json(payload);
  });

  app.get("/v1/studio/models", async (ctx) => {
    const recipes = context.stores.recipeStore.list();
    const recipesByPath = new Map<string, string[]>();
    const recipesByBasename = new Map<string, string[]>();

    const expandUserPath = (pathValue: string): string => {
      if (pathValue.startsWith("~")) {
        return resolve(pathValue.replace("~", homedir()));
      }
      return resolve(pathValue);
    };

    for (const recipe of recipes) {
      const modelPath = recipe.model_path?.trim();
      if (!modelPath) {
        continue;
      }
      const name = basename(modelPath);
      const existingNames = recipesByBasename.get(name) ?? [];
      existingNames.push(recipe.id);
      recipesByBasename.set(name, existingNames);
      if (modelPath.startsWith("/")) {
        const canonical = expandUserPath(modelPath);
        const existingPaths = recipesByPath.get(canonical) ?? [];
        existingPaths.push(recipe.id);
        recipesByPath.set(canonical, existingPaths);
      }
    }

    const rootIndex = new Map<
      string,
      { path: string; exists: boolean; sources: Set<string>; recipeIds: Set<string> }
    >();

    const addRoot = (pathValue: string, source: string, recipeId?: string): void => {
      const resolvedPath = expandUserPath(pathValue);
      const entry = rootIndex.get(resolvedPath) ?? {
        path: resolvedPath,
        exists: existsSync(resolvedPath),
        sources: new Set<string>(),
        recipeIds: new Set<string>(),
      };
      entry.sources.add(source);
      if (recipeId) {
        entry.recipeIds.add(recipeId);
      }
      rootIndex.set(resolvedPath, entry);
    };

    addRoot(context.config.models_dir, "config");

    for (const recipe of recipes) {
      const modelPath = recipe.model_path?.trim();
      if (!modelPath || !modelPath.startsWith("/")) {
        continue;
      }
      const parent = dirname(expandUserPath(modelPath));
      if (parent === "/") {
        continue;
      }
      addRoot(parent, "recipe_parent", recipe.id);
    }

    const roots = Array.from(rootIndex.values()).sort((left, right) =>
      left.path.localeCompare(right.path),
    );
    const scanRoots = roots.filter((root) => root.exists).map((root) => root.path);

    const modelDirectories = discoverModelDirectories(scanRoots, 2, 1000);
    const models = [];
    for (const directory of modelDirectories) {
      const canonical = resolve(directory);
      let recipeIds = recipesByPath.get(canonical) ?? [];
      if (recipeIds.length === 0) {
        const byName = recipesByBasename.get(basename(directory)) ?? [];
        if (byName.length === 1) {
          recipeIds = [...byName];
        }
      }
      const info = await buildModelInfo(directory, recipeIds);
      models.push(info);
    }
    models.sort((left, right) =>
      String(left.name).toLowerCase().localeCompare(String(right.name).toLowerCase()),
    );

    const rootsPayload = roots.map((root) => ({
      path: root.path,
      exists: Boolean(root.exists),
      sources: Array.from(root.sources).sort(),
      recipe_ids: Array.from(root.recipeIds).sort(),
    }));

    return ctx.json({
      models,
      roots: rootsPayload,
      configured_models_dir: context.config.models_dir,
    });
  });

  app.get("/v1/huggingface/models", async (ctx) => {
    const search = ctx.req.query("search")?.trim() || undefined;
    const filter = ctx.req.query("filter") || undefined;
    const sort = ctx.req.query("sort")?.trim() || undefined;
    const limit = Math.min(Math.max(Number(ctx.req.query("limit") ?? 50), 1), 100);
    const offset = Math.max(Number(ctx.req.query("offset") ?? 0), 0);

    const sortMapping: Record<string, string> = {
      createdAt: "createdAt",
      trending: "trendingScore",
      downloads: "downloads",
      likes: "likes",
      lastModified: "lastModified",
      modified: "lastModified",
    };
    const hfSort = sort ? (sortMapping[sort] ?? "trendingScore") : undefined;
    const requestLimit = Math.min(limit + offset, 500);
    const params = new URLSearchParams({
      limit: String(requestLimit),
      full: "false",
    });
    if (hfSort) {
      params.set("sort", hfSort);
    }
    if (search) {
      params.set("search", search);
    }
    if (filter) {
      params.set("filter", filter);
    }

    const normalize = (model: Record<string, unknown>): Record<string, unknown> => {
      const modelId = String(model["modelId"] ?? model["id"] ?? "");
      return {
        ...model,
        _id: String(model["_id"] ?? modelId),
        modelId,
        downloads: Number(model["downloads"] ?? 0),
        likes: Number(model["likes"] ?? 0),
        tags: Array.isArray(model["tags"]) ? model["tags"] : [],
        private: Boolean(model["private"]),
      };
    };

    const url = `https://huggingface.co/api/models?${params.toString()}`;
    try {
      const [listResponse, exactResponse] = await Promise.all([
        fetch(url),
        search && search.includes("/")
          ? fetch(
              `https://huggingface.co/api/models/${search.split("/").map(encodeURIComponent).join("/")}`,
            )
          : Promise.resolve(null),
      ]);
      if (!listResponse.ok) {
        return ctx.json(
          { detail: `HuggingFace API error: ${listResponse.status}` },
          { status: listResponse.status },
        );
      }
      const data = ((await listResponse.json()) as Record<string, unknown>[]).map(normalize);
      let results = data.slice(offset, offset + limit);

      if (exactResponse?.ok) {
        const exact = normalize((await exactResponse.json()) as Record<string, unknown>);
        const exactId = String(exact["modelId"] ?? "").toLowerCase();
        if (exactId) {
          results = [
            exact,
            ...results.filter((entry) => String(entry["modelId"] ?? "").toLowerCase() !== exactId),
          ];
        }
      }

      return ctx.json(results);
    } catch (error) {
      return ctx.json(
        { detail: `Failed to reach HuggingFace API: ${String(error)}` },
        { status: 503 },
      );
    }
  });
};