const {
  getDictItemsWithTypes,
  getDictTypes,
  addDictType,
  addDictItem,
  getDictTypeById,
  getDictItemById,
  getDictItemsByTypeCode,
  updateDictType,
  updateDictItem,
  deleteDictType,
  deleteDictItem,
  checkParentCodeExists,
  hasChildReferences,
} = require('../db/dict.js');

/**
 * 服务层：查询字典项及其类型
 * @returns {Promise<Array>} 字典项列表
 */
async function fetchDictItemsWithTypes() {
  try {
    return await getDictItemsWithTypes();
  } catch (error) {
    console.error("服务层: 查询字典项及其类型失败", error);
    throw error;
  }
}

/**
 * 服务层：查询字典类型列表
 * @returns {Promise<Array>} 字典类型列表
 */
async function fetchDictTypes() {
  try {
    return await getDictTypes();
  } catch (error) {
    console.error("服务层: 查询字典类型列表失败", error);
    throw error;
  }
}

/**
 * 服务层：添加字典类型
 * @param {Object} typeData 字典类型数据
 * @returns {Promise<Object>} 添加的字典类型
 */
async function createDictType(typeData) {
  try {
    return await addDictType(typeData);
  } catch (error) {
    console.error("服务层: 添加字典类型失败", error);
    throw error;
  }
}

/**
 * 服务层：添加字典项
 * @param {Object} itemData 字典项数据
 * @returns {Promise<Object>} 添加的字典项
 */
async function createDictItem(itemData) {
  try {
    return await addDictItem(itemData);
  } catch (error) {
    console.error("服务层: 添加字典项失败", error);
    throw error;
  }
}

/**
 * 服务层：根据ID查询字典类型
 * @param {number} id 字典类型ID
 * @returns {Promise<Object|null>} 字典类型数据
 */
async function fetchDictTypeById(id) {
  try {
    return await getDictTypeById(id);
  } catch (error) {
    console.error("服务层: 根据ID查询字典类型失败", error);
    throw error;
  }
}

/**
 * 服务层：根据ID查询字典项
 * @param {number} id 字典项ID
 * @returns {Promise<Object|null>} 字典项数据
 */
async function fetchDictItemById(id) {
  try {
    return await getDictItemById(id);
  } catch (error) {
    console.error("服务层: 根据ID查询字典项失败", error);
    throw error;
  }
}

/**
 * 服务层：根据类型编码查询字典项
 * @param {string} typeCode 类型编码
 * @param {number} isActive 是否激活(1=激活, 0=未激活, 不传=全部)
 * @returns {Promise<Array>} 字典项列表
 */
async function fetchDictItemsByTypeCode(typeCode, isActive = undefined) {
  try {
    return await getDictItemsByTypeCode(typeCode, isActive);
  } catch (error) {
    console.error("服务层: 根据类型编码查询字典项失败", error);
    throw error;
  }
}

/**
 * 服务层：更新字典类型
 * @param {number} id 字典类型ID
 * @param {Object} typeData 更新的数据
 * @returns {Promise<boolean>} 是否更新成功
 */
async function modifyDictType(id, typeData) {
  try {
    return await updateDictType(id, typeData);
  } catch (error) {
    console.error("服务层: 更新字典类型失败", error);
    throw error;
  }
}

/**
 * 服务层：更新字典项
 * @param {number} id 字典项ID
 * @param {Object} itemData 更新的数据
 * @returns {Promise<boolean>} 是否更新成功
 */
async function modifyDictItem(id, itemData) {
  try {
    return await updateDictItem(id, itemData);
  } catch (error) {
    console.error("服务层: 更新字典项失败", error);
    throw error;
  }
}

/**
 * 服务层：删除字典类型
 * @param {number} id 字典类型ID
 * @returns {Promise<boolean>} 是否删除成功
 */
async function removeDictType(id) {
  try {
    return await deleteDictType(id);
  } catch (error) {
    console.error("服务层: 删除字典类型失败", error);
    throw error;
  }
}

/**
 * 服务层：删除字典项
 * @param {number} id 字典项ID
 * @returns {Promise<boolean>} 是否删除成功
 */
async function removeDictItem(id) {
  try {
    return await deleteDictItem(id);
  } catch (error) {
    console.error("服务层: 删除字典项失败", error);
    throw error;
  }
}

/**
 * 服务层：检查父级编码是否存在
 * @param {string} parentCode 父级编码
 * @returns {Promise<boolean>} 是否存在
 */
async function checkDictParentCode(parentCode) {
  try {
    return await checkParentCodeExists(parentCode);
  } catch (error) {
    console.error("服务层: 检查父级编码失败", error);
    throw error;
  }
}

/**
 * 服务层：检查是否有子引用
 * @param {string} itemCode 字典项编码
 * @returns {Promise<boolean>} 是否有子引用
 */
async function checkDictChildReferences(itemCode) {
  try {
    return await hasChildReferences(itemCode);
  } catch (error) {
    console.error("服务层: 检查子引用失败", error);
    throw error;
  }
}

/**
 * 初始化字典相关的IPC处理程序
 * @param {import('electron').IpcMain} ipcMain - IPC主进程实例
 */
function initDictIpc(ipcMain) {
  // 字典管理相关IPC
  ipcMain.handle("dict-fetch-types", async () => {
    try {
      return await fetchDictTypes();
    } catch (error) {
      console.error("Failed to fetch dict types:", error);
      throw error;
    }
  });

  ipcMain.handle(
    "dict-fetch-items-by-type",
    async (event, typeCode, isActive = undefined) => {
      try {
        return await fetchDictItemsByTypeCode(typeCode, isActive);
      } catch (error) {
        console.error(`Failed to fetch dict items by type ${typeCode}:`, error);
        throw error;
      }
    }
  );

  ipcMain.handle("dict-create-type", async (event, dictType) => {
    try {
      return await createDictType(dictType);
    } catch (error) {
      console.error("Failed to create dict type:", error);
      throw error;
    }
  });

  // 将 updateDictType 改为 modifyDictType
  ipcMain.handle("dict-update-type", async (event, dictType) => {
    try {
      return await modifyDictType(dictType.id, dictType);
    } catch (error) {
      console.error("Failed to update dict type:", error);
      throw error;
    }
  });

  // 将 deleteDictType 改为 removeDictType
  ipcMain.handle("dict-delete-type", async (event, typeCode) => {
    try {
      return await removeDictType(typeCode);
    } catch (error) {
      console.error(`Failed to delete dict type ${typeCode}:`, error);
      throw error;
    }
  });

  ipcMain.handle("dict-create-item", async (event, dictItem) => {
    try {
      return await createDictItem(dictItem);
    } catch (error) {
      console.error("Failed to create dict item:", error);
      throw error;
    }
  });

  // 将 updateDictItem 改为 modifyDictItem
  ipcMain.handle("dict-update-item", async (event, dictItem) => {
    try {
      return await modifyDictItem(dictItem.id, dictItem);
    } catch (error) {
      console.error("Failed to update dict item:", error);
      throw error;
    }
  });

  // 将 deleteDictItem 改为 removeDictItem
  ipcMain.handle("dict-delete-item", async (event, id) => {
    try {
      return await removeDictItem(id);
    } catch (error) {
      console.error(`Failed to delete dict item ${id}:`, error);
      throw error;
    }
  });

  // 将 fetchAllDictItemsWithTypes 改为 fetchDictItemsWithTypes
  ipcMain.handle("dict-fetch-all-items-with-types", async () => {
    try {
      return await fetchDictItemsWithTypes();
    } catch (error) {
      console.error("Failed to fetch all dict items with types:", error);
      throw error;
    }
  });

  // 检查parent_code是否存在
  ipcMain.handle("dict-check-parent-code", async (event, parentCode) => {
    try {
      return await checkDictParentCode(parentCode);
    } catch (error) {
      console.error("检查parent_code失败:", error);
      throw error;
    }
  });

  // 检查是否有子引用
  ipcMain.handle("dict-check-child-references", async (event, itemCode) => {
    try {
      return await checkDictChildReferences(itemCode);
    } catch (error) {
      console.error("检查子引用失败:", error);
      throw error;
    }
  });
}

// 导出使用CommonJS格式
module.exports = {
  fetchDictItemsWithTypes,
  fetchDictTypes,
  createDictType,
  createDictItem,
  fetchDictTypeById,
  fetchDictItemById,
  fetchDictItemsByTypeCode,
  modifyDictType,
  modifyDictItem,
  removeDictType,
  removeDictItem,
  checkDictParentCode,
  checkDictChildReferences,
  initDictIpc
};