import { connect } from "node:net";
import { hostname } from "node:os";
import { access, readFile } from "node:fs/promises";
import { join, resolve, sep } from "node:path";
import { Effect, Schema } from "effect";
import { documentRoute, defineRoutes, mergeRoutes } from "../../http/route-registrar";
import type { SystemConfigResponse } from "../models/types";
import { badRequest, notFound } from "../../core/errors";
import { decodeJsonBody } from "../../core/validation";
import { effectHandler } from "../../http/effect-handler";
import { findObservedInferenceProcess } from "../../core/function-observability";
import { estimateWeightsSizeBytes } from "../models/model-browser";
import { getGpuInfo } from "./platform/gpu";
import { getSystemRuntimeInfo } from "../engines/runtimes/runtime-info";
import { buildCompatibilityReport } from "./platform/compatibility-report";
import { registerMonitoringRoutes } from "./metrics-routes";
import { registerLogsRoutes } from "./logs-routes";
import { registerUsageRoutes } from "./usage-routes";
const SYSTEM_SERVICE_CHECK_HOST = "127.0.0.1";
const SYSTEM_COMPAT_SERVICE_CHECK_TIMEOUT_MS = 500;
const SYSTEM_DEFAULT_SERVICE_CHECK_TIMEOUT_MS = 1_000;
const PositiveNumberSchema = Schema.Number.pipe(
  Schema.check(Schema.isFinite(), Schema.isGreaterThan(0)),
);
const PositiveIntegerSchema = PositiveNumberSchema.pipe(Schema.check(Schema.isInt()));
const ModelDimensionSchema = Schema.Union([Schema.Number, Schema.NumberFromString]).pipe(
  Schema.check(Schema.isFinite(), Schema.isGreaterThan(0)),
);
const VramCalculatorBodySchema = Schema.Struct({
  model: Schema.String,
  context_length: PositiveNumberSchema,
  tp_size: Schema.optionalKey(PositiveIntegerSchema),
  kv_dtype: Schema.optionalKey(Schema.String),
});
const ModelConfigSchema = Schema.Struct({
  num_hidden_layers: Schema.optionalKey(ModelDimensionSchema),
  n_layer: Schema.optionalKey(ModelDimensionSchema),
  num_layers: Schema.optionalKey(ModelDimensionSchema),
  hidden_size: Schema.optionalKey(ModelDimensionSchema),
  n_embd: Schema.optionalKey(ModelDimensionSchema),
  d_model: Schema.optionalKey(ModelDimensionSchema),
  dim: Schema.optionalKey(ModelDimensionSchema),
  num_attention_heads: Schema.optionalKey(ModelDimensionSchema),
  n_head: Schema.optionalKey(ModelDimensionSchema),
  num_heads: Schema.optionalKey(ModelDimensionSchema),
  num_key_value_heads: Schema.optionalKey(ModelDimensionSchema),
  num_kv_heads: Schema.optionalKey(ModelDimensionSchema),
  head_dim: Schema.optionalKey(ModelDimensionSchema),
});

export const registerSystemRoutes = defineRoutes((app, context) => {
  const checkService = (
    host: string,
    port: number,
    timeoutMs = SYSTEM_DEFAULT_SERVICE_CHECK_TIMEOUT_MS,
  ): Effect.Effect<boolean> =>
    Effect.callback<boolean>((resume, signal) => {
      const socket = connect({ port, host });
      let settled = false;
      const cleanup = (): void => {
        socket.removeListener("connect", onConnect);
        socket.removeListener("timeout", onTimeout);
        socket.removeListener("error", onError);
        signal.removeEventListener("abort", onAbort);
        socket.destroy();
      };
      const finalize = (result: boolean): void => {
        if (settled) return;
        settled = true;
        cleanup();
        resume(Effect.succeed(result));
      };
      const onConnect = (): void => finalize(true);
      const onTimeout = (): void => finalize(false);
      const onError = (): void => finalize(false);
      const onAbort = (): void => finalize(false);

      socket.setTimeout(timeoutMs);
      socket.once("connect", onConnect);
      socket.once("timeout", onTimeout);
      socket.once("error", onError);
      signal.addEventListener("abort", onAbort, { once: true });
      return Effect.sync(cleanup);
    });

  return mergeRoutes(
    app.get(
      "/status",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const current = yield* findObservedInferenceProcess(context, "status");
          return ctx.json({
            running: Boolean(current),
            process: current,
            inference_port: context.config.inference_port,
            launching: context.bridge.launchingRecipeId(),
            launch_failures: context.launchFailureBudget.listActive(),
          });
        }),
      ),
    ),

    app.get(
      "/gpus",
      documentRoute,
      effectHandler((ctx) =>
        getGpuInfo().pipe(Effect.map((gpus) => ctx.json({ count: gpus.length, gpus }))),
      ),
    ),

    app.get(
      "/compat",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const known = yield* findObservedInferenceProcess(context, "compat");
          const runtime = yield* getSystemRuntimeInfo(context.config, known);
          const portOpen = yield* checkService(
            SYSTEM_SERVICE_CHECK_HOST,
            context.config.inference_port,
            SYSTEM_COMPAT_SERVICE_CHECK_TIMEOUT_MS,
          );
          return ctx.json(
            buildCompatibilityReport({
              runtime,
              inference_port: context.config.inference_port,
              inference_port_open: portOpen,
              inference_process_known: Boolean(known),
              gpu_monitoring: runtime.gpu_monitoring,
            }),
          );
        }),
      ),
    ),

    app.post(
      "/vram-calculator",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const body = yield* decodeJsonBody(ctx, VramCalculatorBodySchema);
          const model = body.model.trim();
          const contextLength = body.context_length;
          const tpSize = body.tp_size ?? 1;
          const kvDtype = body.kv_dtype ?? "auto";

          if (!model) return yield* Effect.fail(badRequest("model is required"));

          const resolved = resolve(model);
          const modelsRoot = resolve(context.config.models_dir);
          const rootPrefix = modelsRoot.endsWith(sep) ? modelsRoot : modelsRoot + sep;
          if (!resolved.startsWith(rootPrefix)) {
            return yield* Effect.fail(badRequest("model must be inside models_dir"));
          }
          const modelExists = yield* Effect.tryPromise({
            try: () => access(resolved),
            catch: (error) => error,
          }).pipe(
            Effect.as(true),
            Effect.catch(() => Effect.succeed(false)),
          );
          if (!modelExists) return yield* Effect.fail(notFound("Model path not found"));

          const weightsBytes = yield* estimateWeightsSizeBytes(resolved, false);
          if (!weightsBytes || weightsBytes <= 0) {
            return yield* Effect.fail(notFound("Model weights not found"));
          }

          const configPath = join(resolved, "config.json");
          const config = yield* Effect.tryPromise({
            try: () => readFile(configPath, "utf-8"),
            catch: (error) => error,
          }).pipe(
            Effect.flatMap((raw) =>
              Effect.try({
                try: () => JSON.parse(raw) as unknown,
                catch: (error) => error,
              }),
            ),
            Effect.flatMap((value) => Schema.decodeUnknownEffect(ModelConfigSchema)(value)),
            Effect.catch(() => Schema.decodeUnknownEffect(ModelConfigSchema)({})),
          );
          const layerCount = config.num_hidden_layers ?? config.n_layer ?? config.num_layers;
          const hiddenSize = config.hidden_size ?? config.n_embd ?? config.d_model ?? config.dim;
          const headCount = config.num_attention_heads ?? config.n_head ?? config.num_heads;
          const keyValueHeadCount = config.num_key_value_heads ?? config.num_kv_heads ?? headCount;
          const headDim =
            config.head_dim ?? (hiddenSize && headCount ? hiddenSize / headCount : undefined);

          const kvBytesPerValue = kvDtype.toLowerCase() === "fp8" ? 1 : 2;
          let kvCacheBytes = 0;
          if (layerCount && keyValueHeadCount && headDim) {
            kvCacheBytes =
              contextLength * layerCount * keyValueHeadCount * headDim * 2 * kvBytesPerValue;
          }

          const weightsTotalGb = weightsBytes / 1024 ** 3;
          const weightsPerGpuGb = weightsTotalGb / tpSize;
          const kvCachePerGpuGb = kvCacheBytes > 0 ? kvCacheBytes / 1024 ** 3 / tpSize : 0;
          const activationsPerGpuGb = Math.max(0.5, weightsPerGpuGb * 0.1);
          const overheadPerGpuGb = 2.0;
          const perGpuGb =
            weightsPerGpuGb + kvCachePerGpuGb + activationsPerGpuGb + overheadPerGpuGb;
          const totalGb = perGpuGb * tpSize;

          const gpus = yield* getGpuInfo();
          let perGpuCapacityGb = 0;
          if (gpus.length >= tpSize && tpSize > 0) {
            const candidates = gpus.slice(0, tpSize).map((gpu) => gpu.memory_total_mb / 1024);
            perGpuCapacityGb = Math.min(...candidates);
          }

          const fits = perGpuCapacityGb > 0 ? perGpuGb <= perGpuCapacityGb : true;
          const utilizationPercent = perGpuCapacityGb > 0 ? (perGpuGb / perGpuCapacityGb) * 100 : 0;

          return ctx.json({
            model_size_gb: weightsTotalGb,
            context_memory_gb: kvCachePerGpuGb * tpSize,
            overhead_gb: overheadPerGpuGb,
            total_gb: totalGb,
            fits_in_vram: fits,
            fits,
            utilization_percent: utilizationPercent,
            breakdown: {
              model_weights_gb: weightsPerGpuGb,
              kv_cache_gb: kvCachePerGpuGb,
              activations_gb: activationsPerGpuGb,
              per_gpu_gb: perGpuGb,
              total_gb: totalGb,
            },
          });
        }),
      ),
    ),

    app.get(
      "/config",
      documentRoute,
      effectHandler((ctx) =>
        Effect.gen(function* () {
          const services: Array<{
            name: string;
            port: number;
            internal_port: number;
            protocol: string;
            status: string;
            description?: string | null;
          }> = [];
          services.push({
            name: "Controller",
            port: context.config.port,
            internal_port: context.config.port,
            protocol: "http",
            status: "running",
            description: "Controller service (Bun/Hono)",
          });

          const current = yield* findObservedInferenceProcess(context, "config");
          const inferenceStatus = current ? "running" : "stopped";

          services.push({
            name: "Inference runtime",
            port: context.config.inference_port,
            internal_port: context.config.inference_port,
            protocol: "http",
            status: inferenceStatus,
            description: "Inference backend (vLLM, SGLang, llama.cpp, or MLX)",
          });

          const frontendReachable = yield* checkService("localhost", 3000);
          services.push({
            name: "Frontend",
            port: 3000,
            internal_port: 3000,
            protocol: "http",
            status: frontendReachable ? "running" : "stopped",
            description: "Next.js web UI",
          });

          const runtime = yield* getSystemRuntimeInfo(context.config, current);

          const payload: SystemConfigResponse = {
            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,
            },
            services,
            environment: {
              controller_url: `http://${hostname()}:${context.config.port}`,
              inference_url: `http://${hostname()}:${context.config.inference_port}`,
              frontend_url: `http://${hostname()}:3000`,
            },
            runtime,
          };

          return ctx.json(payload);
        }),
      ),
    ),

    registerMonitoringRoutes(app, context),
    registerLogsRoutes(app, context),
    registerUsageRoutes(app, context),
  );
});