import { Hono } from "hono";
import debug from "debug";
import type {
  RackInfo
} from "../client/share/monitorTypes.ts";

import {
  DeleteStatus
} from "../client/share/types.ts";

import type { Variables , WithAuth } from "./middlewares.ts";

const log = {
  api: debug("d8d:rack:api"),
};

// 创建机柜管理 API 的工厂函数
export function createRackRoutes(withAuth: WithAuth) {
  const rackRoutes = new Hono<{ Variables: Variables }>();

  // 获取机柜列表
  rackRoutes.get("/", withAuth, async (c) => {
    try {
      const apiClient = c.get('apiClient');

      // 获取分页参数
      const page = Number(c.req.query("page")) || 1;
      const limit = Number(c.req.query("limit")) || 10;
      const offset = (page - 1) * limit;

      // 获取筛选参数
      const rackName = c.req.query("rack_name") || "";
      const rackCode = c.req.query("rack_code") || "";
      const area = c.req.query("area") || "";
      const room = c.req.query("room") || "";

      // 构建查询
      let query = apiClient.database
        .table("rack_info")
        .where("is_deleted", DeleteStatus.NOT_DELETED);

      // 应用筛选条件
      if (rackName) {
        query = query.where("rack_name", "like", `%${rackName}%`);
      }

      if (rackCode) {
        query = query.where("rack_code", "like", `%${rackCode}%`);
      }

      if (area) {
        query = query.where("area", "like", `%${area}%`);
      }

      if (room) {
        query = query.where("room", "like", `%${room}%`);
      }

      // 获取总记录数
      const total = await query.clone().count();

      // 获取分页数据
      const racks = await query
        .select("*")
        .limit(limit)
        .offset(offset)
        .orderBy("created_at", "desc");

      // 返回结果
      return c.json({
        data: racks,
        pagination: {
          total,
          current: page,
          pageSize: limit,
        },
      });
    } catch (error: any) {
      log.api("获取机柜列表失败:", error);
      return c.json({ error: "获取机柜列表失败" }, 500);
    }
  });

  // 获取机柜详情
  rackRoutes.get("/:id", withAuth, async (c) => {
    try {
      const id = Number(c.req.param("id"));

      if (!id || isNaN(id)) {
        return c.json({ error: "无效的机柜ID" }, 400);
      }

      const apiClient = c.get('apiClient');

      // 查询机柜
      const rack = await apiClient.database
        .table("rack_info")
        .where("id", id)
        .where("is_deleted", DeleteStatus.NOT_DELETED)
        .first();

      if (!rack) {
        return c.json({ error: "机柜不存在" }, 404);
      }

      return c.json(rack);
    } catch (error) {
      log.api("获取机柜详情失败:", error);
      return c.json({ error: "获取机柜详情失败" }, 500);
    }
  });

  // 创建机柜
  rackRoutes.post("/", withAuth, async (c) => {
    try {
      const rackData = (await c.req.json()) as Partial<RackInfo>;

      // 验证必填字段
      if (!rackData.rack_name) {
        return c.json({ error: "机柜名称不能为空" }, 400);
      }

      if (!rackData.rack_code) {
        return c.json({ error: "机柜编号不能为空" }, 400);
      }

      const apiClient = c.get('apiClient');

      // 检查是否已存在相同编号的机柜
      const existingRack = await apiClient.database
        .table("rack_info")
        .where("rack_code", rackData.rack_code)
        .where("is_deleted", DeleteStatus.NOT_DELETED)
        .first();

      if (existingRack) {
        return c.json({ error: "已存在相同编号的机柜" }, 400);
      }

      // 插入机柜
      const [id] = await apiClient.database.table("rack_info").insert({
        ...rackData,
        created_at: apiClient.database.fn.now(),
        updated_at: apiClient.database.fn.now(),
      });

      return c.json({
        message: "创建机柜成功",
        id,
      });
    } catch (error) {
      log.api("创建机柜失败:", error);
      return c.json({ error: "创建机柜失败" }, 500);
    }
  });

  // 更新机柜
  rackRoutes.put("/:id", withAuth, async (c) => {
    try {
      const id = Number(c.req.param("id"));

      if (!id || isNaN(id)) {
        return c.json({ error: "无效的机柜ID" }, 400);
      }

      const rackData = (await c.req.json()) as Partial<RackInfo>;

      const apiClient = c.get('apiClient');

      // 检查机柜是否存在
      const existingRack = await apiClient.database
        .table("rack_info")
        .where("id", id)
        .where("is_deleted", DeleteStatus.NOT_DELETED)
        .first();

      if (!existingRack) {
        return c.json({ error: "机柜不存在" }, 404);
      }

      // 检查编号是否与其他机柜冲突
      if (rackData.rack_code !== existingRack.rack_code) {
        const conflictRack = await apiClient.database
          .table("rack_info")
          .where("rack_code", rackData.rack_code || "")
          .where("id", "!=", id)
          .where("is_deleted", DeleteStatus.NOT_DELETED)
          .first();

        if (conflictRack) {
          return c.json({ error: "已存在相同编号的机柜" }, 400);
        }
      }

      // 更新机柜
      await apiClient.database
        .table("rack_info")
        .where("id", id)
        .update({
          ...rackData,
          updated_at: apiClient.database.fn.now(),
        });

      return c.json({
        message: "更新机柜成功",
        id,
      });
    } catch (error) {
      log.api("更新机柜失败:", error);
      return c.json({ error: "更新机柜失败" }, 500);
    }
  });

  // 删除机柜
  rackRoutes.delete("/:id", withAuth, async (c) => {
    try {
      const id = Number(c.req.param("id"));

      if (!id || isNaN(id)) {
        return c.json({ error: "无效的机柜ID" }, 400);
      }

      const apiClient = c.get('apiClient');

      // 检查机柜是否存在
      const existingRack = await apiClient.database
        .table("rack_info")
        .where("id", id)
        .where("is_deleted", DeleteStatus.NOT_DELETED)
        .first();

      if (!existingRack) {
        return c.json({ error: "机柜不存在" }, 404);
      }

      // 检查是否有关联的服务器
      const relatedServers = await apiClient.database
        .table("rack_server")
        .where("rack_id", id)
        .where("is_deleted", DeleteStatus.NOT_DELETED)
        .first();

      if (relatedServers) {
        return c.json({ error: "该机柜下存在服务器设备，无法删除" }, 400);
      }

      // 软删除机柜
      await apiClient.database.table("rack_info").where("id", id).update({
        is_deleted: DeleteStatus.DELETED,
        updated_at: apiClient.database.fn.now(),
      });

      return c.json({
        message: "删除机柜成功",
        id,
      });
    } catch (error) {
      log.api("删除机柜失败:", error);
      return c.json({ error: "删除机柜失败" }, 500);
    }
  });

  return rackRoutes;
}