import { basename, dirname, resolve } from "node:path";
import { existsSync } from "node:fs";
import { homedir } from "node:os";
import { Effect, Schema } from "effect";
import { effectHandler } from "../../http/effect-handler";
import { documentRoute, defineRoutes, mergeRoutes } from "../../http/route-registrar";
import type { Recipe } from "../models/types";
import { resolveModelVision } from "@local-studio/contracts/model-capabilities";

interface OpenAIModelInfo {
  id: string;
  object: "model";
  created: number;
  owned_by: string;
  active: boolean;
  max_model_len?: number | null;
  metadata: Record<string, unknown>;
}

interface OpenAIModelList {
  object: "list";
  data: OpenAIModelInfo[];
}

const ActiveModelsSchema = Schema.Struct({
  data: Schema.optional(
    Schema.Array(Schema.Struct({ max_model_len: Schema.optional(Schema.Number) })),
  ),
});

const HuggingFaceModelsSchema = Schema.Array(Schema.Record(Schema.String, Schema.Unknown));
const HuggingFaceModelSchema = Schema.Record(Schema.String, Schema.Unknown);

const decodeResponse = <S extends Schema.Constraint>(
  response: Response,
  schema: S,
): Effect.Effect<S["Type"], unknown, S["DecodingServices"]> =>
  Effect.tryPromise({ try: () => response.json(), catch: (source) => source }).pipe(
    Effect.flatMap(Schema.decodeUnknownEffect(schema)),
  );
import { buildModelInfo, discoverModelDirectories } from "./model-browser";
import { isRecipeRunning } from "./recipes/recipe-matching";
import { notFound } from "../../core/errors";
import { findObservedInferenceProcess } from "../../core/function-observability";
import { fetchInference } from "../../http/local-fetch";

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 = defineRoutes((app, context) => {
  return mergeRoutes(
    app.get(
      "/v1/models",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const recipes = yield* context.stores.recipeStore.list();
          const current = yield* findObservedInferenceProcess(context, "models.list");
          let activeModelData: {
            readonly data?: readonly { readonly max_model_len?: number | undefined }[] | undefined;
          } | null = null;
          if (current) {
            activeModelData = yield* fetchInference(context, "/v1/models", {
              timeoutMs: 5000,
            }).pipe(
              Effect.flatMap((response) =>
                response.ok ? decodeResponse(response, ActiveModelsSchema) : Effect.succeed(null),
              ),
              Effect.catch(() => Effect.succeed(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) {
              isActive = isRecipeRunning(recipe, current, { allowEitherPathContains: 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),
            });
          }

          if (models.length === 0 && current) {
            const inferredId =
              current?.served_model_name ||
              (current?.model_path ? basename(current.model_path) : "") ||
              "active-model";
            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",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const modelId = ctx.req.param("modelId");
          const recipes = yield* 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) {
            return yield* Effect.fail(notFound("Model not found"));
          }

          const current = yield* findObservedInferenceProcess(context, "models.detail");
          let isActive = false;
          let maxModelLength = recipe.max_model_len;
          if (current && isRecipeRunning(recipe, current, { allowEitherPathContains: true })) {
            isActive = true;
            const data = yield* fetchInference(context, "/v1/models", { timeoutMs: 5000 }).pipe(
              Effect.flatMap((response) =>
                response.ok ? decodeResponse(response, ActiveModelsSchema) : Effect.succeed(null),
              ),
              Effect.catch(() => Effect.succeed(null)),
            );
            maxModelLength = data?.data?.[0]?.max_model_len ?? 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",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const recipes = yield* 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 = yield* discoverModelDirectories(scanRoots, 2, 1000);
          const models = yield* Effect.forEach(
            modelDirectories,
            (directory) => {
              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];
                }
              }
              return buildModelInfo(directory, recipeIds);
            },
            { concurrency: "unbounded" },
          );
          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",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          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()}`;
          return yield* Effect.all([
            Effect.tryPromise({ try: () => fetch(url), catch: (source) => source }),
            search && search.includes("/")
              ? Effect.tryPromise({
                  try: () =>
                    fetch(
                      `https://huggingface.co/api/models/${search.split("/").map(encodeURIComponent).join("/")}`,
                    ),
                  catch: (source) => source,
                })
              : Effect.succeed(null),
          ]).pipe(
            Effect.flatMap(([listResponse, exactResponse]) =>
              Effect.gen(function* () {
                if (!listResponse.ok) {
                  return Response.json(
                    { detail: `HuggingFace API error: ${listResponse.status}` },
                    { status: listResponse.status },
                  );
                }
                const data = (yield* decodeResponse(listResponse, HuggingFaceModelsSchema)).map(
                  normalize,
                );
                let results = data.slice(offset, offset + limit);

                if (exactResponse?.ok) {
                  const exact = normalize(
                    yield* decodeResponse(exactResponse, HuggingFaceModelSchema),
                  );
                  const exactId = String(exact["modelId"] ?? "").toLowerCase();
                  if (exactId) {
                    results = [
                      exact,
                      ...results.filter(
                        (entry) => String(entry["modelId"] ?? "").toLowerCase() !== exactId,
                      ),
                    ];
                  }
                }

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