const prisma = require("../utils/prisma");
const { User } = require("../models/user");
const { Dept } = require("../models/dept");

/**
 * @typedef {Object} DeptUser
 * @property {number} id
 * @property {number} deptId
 * @property {number} userId
 * @property {Date} createdAt
 * @property {Date} updatedAt
 */

const DeptUsers = {
  writable: ["deptId", "userId"],
  validations: {
    deptId: (newValue) => {
      const num = Number(newValue);
      if (isNaN(num)) {
        throw new Error("Dept ID must be a number");
      }
      return num;
    },
    userId: (newValue) => {
      const num = Number(newValue);
      if (isNaN(num)) {
        throw new Error("User ID must be a number");
      }
      return num;
    },
  },
  castColumnValue: function (key, value) {
    switch (key) {
      case "deptId":
      case "userId":
        return Number(value);
      default:
        return value;
    }
  },

  /**
   * 创建组织机构用户关联
   * @param {Object} data - 组织机构用户数据
   * @returns {Promise<{ deptUser: DeptUser | null, error: string | null }>}
   */
  create: async function (data) {
    try {
      const { userId, deptId } = data.data;
      console.log("创建组织机构用户关联:", userId);
      console.log("创建组织机构用户关联:", deptId);

      // 检查 userId 和 deptId 是否存在
      const userExists = await User.get({
         id: userId
      });
      if (!userExists) {
        throw new Error(`用户 ID ${userId} 不存在`);
      }

      const deptExists = await Dept.get({
        deptId: parseInt(deptId)
      });
      if (!deptExists) {
        throw new Error(`部门 ID ${deptId} 不存在`);
      }

      // 创建 dept_users 记录
      const deptUser = await prisma.dept_users.create({
        data: {
          // userId: userId,
          // deptId: parseInt(deptId),
          createdAt: new Date(),
          updatedAt: new Date(),
          user: {
            connect: {
              id: userId,
            },
          },
          dept: {
            connect: {
              deptId: parseInt(deptId),
            },
          },
        },
      });

      return deptUser;
    } catch (error) {
      console.error("创建 dept_users 记录时出错:", error.message);
      throw error;
    }
  },
  createNew: async function (data,prisma) {
    try {
      const { userId, deptId } = data.data;
      // 检查 userId 和 deptId 是否存在
      const userExists = await User.getNew({
        id: userId,
      },prisma);
      if (!userExists) {
        throw new Error(`用户 ID ${userId} 不存在`);
      }
      const deptExists = await Dept.get({
        deptId: parseInt(deptId),
      });
      if (!deptExists) {
        throw new Error(`部门 ID ${deptId} 不存在`);
      }
      // 创建 dept_users 记录
      const deptUser = await prisma.dept_users.create({
        data: {
          // userId: userId,
          // deptId: parseInt(deptId),
          createdAt: new Date(),
          updatedAt: new Date(),
          user: {
            connect: {
              id: userId,
            },
          },
          dept: {
            connect: {
              deptId: parseInt(deptId),
            },
          },
        },
      });

      return deptUser;
    } catch (error) {
      console.error("创建 dept_users 记录时出错:", error.message);
      throw error;
    }
  },

  /**
   * 更新组织机构用户关联
   * @param {number} id - 关联 ID
   * @param {Object} updates - 更新的字段
   * @returns {Promise<{ success: boolean, error: string | null, deptUser: DeptUser | null }>}
   */
  update: async function (id, updates = {}) {
    try {
      if (!id) throw new Error("No ID provided for update");

      const currentDeptUser = await prisma.dept_users.findUnique({
        where: { id },
      });
      if (!currentDeptUser) throw new Error("Dept user not found");

      const validatedUpdates = {};
      for (const key of this.writable) {
        if (updates[key] !== undefined) {
          if (this.validations[key]) {
            validatedUpdates[key] = this.validations[key](updates[key]);
          } else {
            validatedUpdates[key] = this.castColumnValue(key, updates[key]);
          }
        }
      }

      validatedUpdates.updatedAt = new Date();

      const updatedDeptUser = await prisma.dept_users.update({
        where: { id },
        data: validatedUpdates,
      });

      return { success: true, error: null, deptUser: updatedDeptUser };
    } catch (error) {
      console.error(error.message);
      return { success: false, error: error.message, deptUser: null };
    }
  },

  /**
   * 获取组织机构用户关联
   * @param {Object} clause - 查询条件
   * @returns {Promise<{ deptUser: DeptUser | null }>}
   */
  get: async function (clause = {}) {
    try {
      const deptUser = await prisma.dept_users.findFirst({
        where: clause,
      });
      return deptUser ? { deptUser } : null;
    } catch (error) {
      console.error(error.message);
      return null;
    }
  },

  /**
   * 删除组织机构用户关联
   * @param {Object} clause - 删除条件
   * @returns {Promise<boolean>}
   */
  delete: async function (clause = {}) {
    try {
      const affectedRows = await prisma.dept_users.deleteMany({
        where: clause,
      });
      return affectedRows.count > 0;
    } catch (error) {
      console.error(error.message);
      return false;
    }
  },

  /**
   * 查询组织机构用户关联列表
   * @param {Object} clause - 查询条件
   * @param {number} limit - 限制数量
   * @returns {Promise<DeptUser[]>}
   */
  where: async function (clause = {}, limit = null) {
    try {
      const deptUsers = await prisma.dept_users.findMany({
        where: clause,
        take: limit !== null ? limit : undefined,
      });
      return deptUsers;
    } catch (error) {
      console.error(error.message);
      return [];
    }
  },
};

module.exports = { DeptUsers };