import { Hono } from "hono";
import debug from "debug";

import type {
  ZichanTransLog
} from "../client/share/monitorTypes.ts";

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

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

// 创建资产流转管理路由
export function createZichanTransferRoutes(withAuth: WithAuth) {
  const zichanTransferRoutes = new Hono<{ Variables: Variables }>();

  // 获取资产流转记录列表
  zichanTransferRoutes.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 assetId = c.req.query("asset_id")
        ? Number(c.req.query("asset_id"))
        : undefined;
      const transferType = c.req.query("asset_transfer")
        ? Number(c.req.query("asset_transfer"))
        : undefined;

      // 构建查询
      let query = apiClient.database
        .table("zichan_trans_log as ztl")
        .leftJoin("zichan_info as zi", "ztl.asset_id", "zi.id")
        .select("ztl.*", "zi.asset_name as asset_name")
        .where("ztl.is_deleted", 0)
        .orderBy("ztl.id", "desc");

      // 应用筛选条件
      if (assetId) {
        query = query.where("ztl.asset_id", assetId);
      }

      if (transferType) {
        query = query.where("ztl.asset_transfer", transferType);
      }

      // 获取总记录数
      const countResult = await query.clone().count();
      const total = countResult ? Number(countResult) : 0;

      // 获取分页数据
      const data = await query.limit(limit).offset(offset);

      // 处理数据，添加资产信息
      const result = data.map((item) => {
        return {
          ...item,
          asset_info: item.asset_name
            ? {
                id: item.asset_id,
                asset_name: item.asset_name,
              }
            : null,
        };
      });

      // 返回结果
      return c.json({
        data: result,
        pagination: {
          total: total,
          current: page,
          pageSize: limit,
        },
      });
    } catch (error) {
      log.api("获取资产流转记录列表失败:", error);
      return c.json({ error: "获取资产流转记录列表失败" }, 500);
    }
  });

  // 获取资产流转记录详情
  zichanTransferRoutes.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 [transferLog] = await apiClient.database
        .table("zichan_trans_log as ztl")
        .leftJoin("zichan_info as zi", "ztl.asset_id", "zi.id")
        .select("ztl.*", "zi.asset_name as asset_name")
        .where("ztl.id", id)
        .where("ztl.is_deleted", 0);

      if (!transferLog) {
        return c.json({ error: "资产流转记录不存在" }, 404);
      }

      // 添加资产信息
      transferLog.asset_info = transferLog.asset_name
        ? {
            id: transferLog.asset_id,
            asset_name: transferLog.asset_name,
          }
        : null;

      return c.json(transferLog);
    } catch (error) {
      log.api("获取资产流转记录详情失败:", error);
      return c.json({ error: "获取资产流转记录详情失败" }, 500);
    }
  });

  // 创建资产流转记录
  zichanTransferRoutes.post("/", withAuth, async (c) => {
    try {
      const transferData = (await c.req.json()) as Partial<ZichanTransLog>;

      // 验证必填字段
      if (!transferData.asset_id) {
        return c.json({ error: "资产ID不能为空" }, 400);
      }

      if (!transferData.asset_transfer) {
        return c.json({ error: "资产流转类型不能为空" }, 400);
      }

      if (!transferData.person) {
        return c.json({ error: "人员不能为空" }, 400);
      }

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

      // 检查资产是否存在
      const [existingAsset] = await apiClient.database
        .table("zichan_info")
        .where({ id: transferData.asset_id, is_deleted: 0 });

      if (!existingAsset) {
        return c.json({ error: "资产不存在" }, 404);
      }

      // 插入资产流转记录
      const [id] = await apiClient.database.table("zichan_trans_log").insert({
        ...transferData,
        created_at: apiClient.database.fn.now(),
        updated_at: apiClient.database.fn.now(),
      });

      // 获取创建的资产流转记录
      const [createdTransferLog] = await apiClient.database
        .table("zichan_trans_log as ztl")
        .leftJoin("zichan_info as zi", "ztl.asset_id", "zi.id")
        .select("ztl.*", "zi.asset_name as asset_name")
        .where("ztl.id", id);

      // 添加资产信息
      createdTransferLog.asset_info = createdTransferLog.asset_name
        ? {
            id: createdTransferLog.asset_id,
            asset_name: createdTransferLog.asset_name,
          }
        : null;

      return c.json({
        message: "资产流转记录创建成功",
        data: createdTransferLog,
      });
    } catch (error) {
      log.api("创建资产流转记录失败:", error);
      return c.json({ error: "创建资产流转记录失败" }, 500);
    }
  });

  // 更新资产流转记录
  zichanTransferRoutes.put("/:id", withAuth, async (c) => {
    try {
      const id = Number(c.req.param("id"));

      if (!id || isNaN(id)) {
        return c.json({ error: "无效的资产流转记录ID" }, 400);
      }

      const transferData = (await c.req.json()) as Partial<ZichanTransLog>;

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

      // 检查资产流转记录是否存在
      const [existingTransferLog] = await apiClient.database
        .table("zichan_trans_log")
        .where({ id, is_deleted: 0 });

      if (!existingTransferLog) {
        return c.json({ error: "资产流转记录不存在" }, 404);
      }

      // 如果更新了资产ID，检查资产是否存在
      if (
        transferData.asset_id &&
        transferData.asset_id !== existingTransferLog.asset_id
      ) {
        const [existingAsset] = await apiClient.database
          .table("zichan_info")
          .where({ id: transferData.asset_id, is_deleted: 0 });

        if (!existingAsset) {
          return c.json({ error: "所选资产不存在" }, 404);
        }
      }

      // 更新资产流转记录
      await apiClient.database
        .table("zichan_trans_log")
        .where("id", id)
        .update({
          ...transferData,
          updated_at: apiClient.database.fn.now(),
        });

      // 获取更新后的资产流转记录
      const [updatedTransferLog] = await apiClient.database
        .table("zichan_trans_log as ztl")
        .leftJoin("zichan_info as zi", "ztl.asset_id", "zi.id")
        .select("ztl.*", "zi.asset_name as asset_name")
        .where("ztl.id", id);

      // 添加资产信息
      updatedTransferLog.asset_info = updatedTransferLog.asset_name
        ? {
            id: updatedTransferLog.asset_id,
            asset_name: updatedTransferLog.asset_name,
          }
        : null;

      return c.json({
        message: "资产流转记录更新成功",
        data: updatedTransferLog,
      });
    } catch (error) {
      log.api("更新资产流转记录失败:", error);
      return c.json({ error: "更新资产流转记录失败" }, 500);
    }
  });

  // 删除资产流转记录（软删除）
  zichanTransferRoutes.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 [existingTransferLog] = await apiClient.database
        .table("zichan_trans_log")
        .where({ id, is_deleted: 0 });

      if (!existingTransferLog) {
        return c.json({ error: "资产流转记录不存在" }, 404);
      }

      // 软删除资产流转记录
      await apiClient.database.table("zichan_trans_log").where("id", id).update({
        is_deleted: 1,
        updated_at: apiClient.database.fn.now(),
      });

      return c.json({
        message: "资产流转记录删除成功",
        id,
      });
    } catch (error) {
      log.api("删除资产流转记录失败:", error);
      return c.json({ error: "删除资产流转记录失败" }, 500);
    }
  });

  return zichanTransferRoutes;
}