import { cp, mkdir, rename, rm, statfs } from "node:fs/promises";
import { cpus, freemem, totalmem, platform, arch, release } from "node:os";
import { basename, resolve, sep } from "node:path";
import { Effect, Schema } from "effect";
import { badRequest, notFound } from "../../core/errors";
import { decodeJsonBody } from "../../core/validation";
import { effectHandler } from "../../http/effect-handler";
import { documentRoute, defineRoutes, mergeRoutes } from "../../http/route-registrar";
import { registerStudioModelIndexRoutes } from "./model-index";
import { registerStudioProviderRoutes } from "./provider-routes";
import { registerStudioRigRoutes } from "./rig-routes";
import { getGpuInfo } from "../system/platform/gpu";
import type { GpuInfo } from "../models/types";
import { discoverModelDirectories, estimateWeightsSizeBytes } from "../models/model-browser";
import { STUDIO_STARTER_PRESETS } from "./configs";
import {
  getPersistedConfigPath,
  loadPersistedConfig,
  savePersistedConfig,
  type PersistedConfig,
} from "../../config/persisted-config";
import { getVllmRuntimeInfo } from "../engines/runtimes/vllm-runtime";

const SettingsUpdateSchema = Schema.Struct({
  models_dir: Schema.optional(Schema.NullOr(Schema.String)),
  ui_preferences: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
});

const ModelDeleteSchema = Schema.Struct({ path: Schema.String });
const ModelMoveSchema = Schema.Struct({ source_path: Schema.String, target_root: Schema.String });

class StudioOperationError extends Schema.TaggedErrorClass<StudioOperationError>()(
  "StudioOperationError",
  {
    operation: Schema.Literals(["disk", "settings", "delete", "move"]),
    message: Schema.String,
    source: Schema.optional(Schema.Unknown),
  },
) {}

interface StudioDiskInfo {
  path: string;
  total_bytes: number | null;
  free_bytes: number | null;
  available_bytes: number | null;
}

const diskInfo = (path: string): Effect.Effect<StudioDiskInfo> =>
  Effect.tryPromise({
    try: () => statfs(path),
    catch: (source) =>
      new StudioOperationError({ operation: "disk", message: "Disk unavailable", source }),
  }).pipe(
    Effect.map((stats) => ({
      path,
      total_bytes: stats.blocks * stats.bsize,
      free_bytes: stats.bfree * stats.bsize,
      available_bytes: stats.bavail * stats.bsize,
    })),
    Effect.catchTag("StudioOperationError", () =>
      Effect.succeed({ path, total_bytes: null, free_bytes: null, available_bytes: null }),
    ),
  );

const insideModelsRoot = (
  modelsDirectory: string,
  target: string,
  label: string,
  allowRoot = false,
): Effect.Effect<string, ReturnType<typeof badRequest>> => {
  const resolved = resolve(target);
  const modelsRoot = resolve(modelsDirectory);
  const rootPrefix = modelsRoot.endsWith(sep) ? modelsRoot : `${modelsRoot}${sep}`;
  return resolved.startsWith(rootPrefix) || (allowRoot && resolved === modelsRoot)
    ? Effect.succeed(resolved)
    : Effect.fail(badRequest(`${label} must be inside models_dir`));
};

const pathExists = (path: string): Effect.Effect<boolean> =>
  Effect.tryPromise({ try: () => statfs(path), catch: (source) => source }).pipe(
    Effect.as(true),
    Effect.catch(() => Effect.succeed(false)),
  );

const normalizedOptionalString = (value: string | null | undefined): string | null | undefined => {
  if (value === undefined || value === null) return value;
  const trimmed = value.trim();
  return trimmed ? trimmed : null;
};

export const deriveRecommendationVramGb = (gpus: GpuInfo[]): number =>
  gpus.reduce((sum, gpu) => sum + gpu.memory_total_mb / 1024, 0);

export const registerStudioRoutes = defineRoutes((app, context) => {
  const buildSettingsPayload = Effect.gen(function* () {
    const persisted = yield* Effect.try({
      try: () => loadPersistedConfig(context.config.data_dir),
      catch: (source) =>
        new StudioOperationError({
          operation: "settings",
          message: "Could not load settings",
          source,
        }),
    });
    const legacyUiPreferences = (
      persisted as PersistedConfig & { ui_preferences?: Record<string, string> }
    ).ui_preferences;
    const dbUiPreferences = yield* context.stores.controllerSettingsStore.getUiPreferencesEffect();
    const uiPreferences =
      Object.keys(dbUiPreferences).length > 0
        ? dbUiPreferences
        : legacyUiPreferences && typeof legacyUiPreferences === "object"
          ? legacyUiPreferences
          : {};
    if (Object.keys(dbUiPreferences).length === 0 && Object.keys(uiPreferences).length > 0) {
      yield* context.stores.controllerSettingsStore.saveUiPreferencesEffect(uiPreferences);
    }
    return {
      config_path: getPersistedConfigPath(context.config.data_dir),
      persisted: { models_dir: persisted.models_dir, ui_preferences: uiPreferences },
      effective: { models_dir: context.config.models_dir },
    };
  });

  return mergeRoutes(
    app.get(
      "/studio/settings",
      documentRoute,
      effectHandler((ctx) => buildSettingsPayload.pipe(Effect.map((payload) => ctx.json(payload)))),
    ),

    app.post(
      "/studio/settings",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const body = yield* decodeJsonBody(ctx, SettingsUpdateSchema);
          const modelsDirectory = normalizedOptionalString(body.models_dir);
          const uiPreferences = body.ui_preferences;
          if (modelsDirectory === undefined && uiPreferences === undefined) {
            return yield* Effect.fail(badRequest("No supported settings provided"));
          }
          const saved = yield* Effect.try({
            try: () =>
              modelsDirectory !== undefined
                ? savePersistedConfig(context.config.data_dir, { models_dir: modelsDirectory })
                : loadPersistedConfig(context.config.data_dir),
            catch: (source) =>
              new StudioOperationError({
                operation: "settings",
                message: "Could not save settings",
                source,
              }),
          });
          if (uiPreferences !== undefined) {
            yield* context.stores.controllerSettingsStore.saveUiPreferencesEffect(
              uiPreferences ?? {},
            );
          }
          if (saved.models_dir) context.config.models_dir = resolve(saved.models_dir);
          const payload = yield* buildSettingsPayload;
          return ctx.json({ success: true, ...payload });
        }),
      ),
    ),

    app.get(
      "/studio/diagnostics",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const cpuList = cpus();
          const [gpus, runtime, disks] = yield* Effect.all([
            getGpuInfo(),
            getVllmRuntimeInfo(),
            Effect.all([diskInfo(context.config.data_dir), diskInfo(context.config.models_dir)]),
          ]);
          return ctx.json({
            app_version: process.env["LOCAL_STUDIO_VERSION"] ?? "dev",
            timestamp: new Date().toISOString(),
            platform: platform(),
            arch: arch(),
            release: release(),
            cpu_model: cpuList[0]?.model ?? null,
            cpu_cores: cpuList.length,
            memory_total: totalmem(),
            memory_free: freemem(),
            gpus,
            runtime: {
              vllm_installed: runtime.installed,
              vllm_version: runtime.version,
              python_path: runtime.python_path,
              vllm_bin: runtime.vllm_bin,
            },
            disks,
            config: {
              host: context.config.host,
              port: context.config.port,
              inference_port: context.config.inference_port,
              api_key_configured: Boolean(context.config.api_key),
              models_dir: context.config.models_dir,
              data_dir: context.config.data_dir,
              db_path: context.config.db_path,
              sglang_python: context.config.sglang_python ?? null,
              llama_bin: context.config.llama_bin ?? null,
              mlx_python: context.config.mlx_python ?? null,
            },
          });
        }),
      ),
    ),

    app.get(
      "/studio/storage",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const directories = yield* discoverModelDirectories([context.config.models_dir], 2, 200);
          const sizes = yield* Effect.forEach(
            directories,
            (directory) =>
              estimateWeightsSizeBytes(directory, false).pipe(
                Effect.map((size) => size ?? 0),
                Effect.orElseSucceed(() => 0),
              ),
            { concurrency: "unbounded" },
          );
          return ctx.json({
            models_dir: context.config.models_dir,
            model_count: directories.length,
            model_bytes: sizes.reduce((total, value) => total + value, 0),
            disk: yield* diskInfo(context.config.models_dir),
          });
        }),
      ),
    ),

    app.get(
      "/studio/presets",
      documentRoute,
      effectHandler((ctx) =>
        getGpuInfo().pipe(
          Effect.map((gpus) => {
            const maxVramGb = deriveRecommendationVramGb(gpus);
            const appleSilicon = platform() === "darwin" && arch() === "arm64";
            const presets = STUDIO_STARTER_PRESETS.filter(
              (preset) => !appleSilicon || preset.backend !== "vllm",
            ).map((preset) => ({
              ...preset,
              fits:
                preset.min_vram_gb === null ||
                maxVramGb === 0 ||
                preset.min_vram_gb <= maxVramGb,
            }));
            return ctx.json({ presets, max_vram_gb: maxVramGb });
          }),
        ),
      ),
    ),

    app.post(
      "/studio/models/delete",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const body = yield* decodeJsonBody(ctx, ModelDeleteSchema);
          if (!body.path.trim()) return yield* Effect.fail(badRequest("path is required"));
          const target = yield* insideModelsRoot(context.config.models_dir, body.path, "path");
          if (!(yield* pathExists(target)))
            return yield* Effect.fail(notFound("Model path not found"));
          yield* Effect.tryPromise({
            try: () => rm(target, { recursive: true, force: true }),
            catch: (source) =>
              new StudioOperationError({
                operation: "delete",
                message: "Could not delete model",
                source,
              }),
          });
          return ctx.json({ success: true });
        }),
      ),
    ),

    app.post(
      "/studio/models/move",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const body = yield* decodeJsonBody(ctx, ModelMoveSchema);
          if (!body.source_path.trim() || !body.target_root.trim()) {
            return yield* Effect.fail(badRequest("source_path and target_root are required"));
          }
          const source = yield* insideModelsRoot(
            context.config.models_dir,
            body.source_path,
            "source_path",
          );
          const targetRoot = yield* insideModelsRoot(
            context.config.models_dir,
            body.target_root,
            "target_root",
            true,
          );
          if (!(yield* pathExists(source)))
            return yield* Effect.fail(notFound("source_path not found"));
          yield* Effect.tryPromise({
            try: () => mkdir(targetRoot, { recursive: true }),
            catch: (sourceError) =>
              new StudioOperationError({
                operation: "move",
                message: "Could not create target",
                source: sourceError,
              }),
          });
          const target = resolve(targetRoot, basename(source));
          if (yield* pathExists(target))
            return yield* Effect.fail(badRequest("Target path already exists"));
          if (source !== target) {
            yield* Effect.tryPromise({
              try: () => rename(source, target),
              catch: (sourceError) => sourceError,
            }).pipe(
              Effect.catch((sourceError) =>
                (sourceError as NodeJS.ErrnoException).code === "EXDEV"
                  ? Effect.tryPromise({
                      try: () =>
                        cp(source, target, { recursive: true, force: false, errorOnExist: true }),
                      catch: (copyError) => copyError,
                    }).pipe(
                      Effect.andThen(
                        Effect.tryPromise({
                          try: () => rm(source, { recursive: true, force: true }),
                          catch: (removeError) => removeError,
                        }),
                      ),
                    )
                  : Effect.fail(sourceError),
              ),
              Effect.mapError(
                (sourceError) =>
                  new StudioOperationError({
                    operation: "move",
                    message: "Could not move model",
                    source: sourceError,
                  }),
              ),
            );
          }
          return ctx.json({ success: true, target });
        }),
      ),
    ),

    registerStudioModelIndexRoutes(app, context),
    registerStudioProviderRoutes(app, context),
    registerStudioRigRoutes(app, context),
  );
});