let db = "";
const { ObjectId } = require("mongodb");
const validator = require('../../utils/validator.js')
const { ensureApplicableDiagnosisIndexes } = require('../drug-info/applicable-diagnosis');
module.exports = async (item, mongodb) => {
  db = mongodb;
  switch (item.type) {
    case "getDiagnosisList":
      return await getDiagnosisList(item);
    case "deleteHlwDiagnosis":
      return await deleteHlwDiagnosis(item);
    case "updateHlwDiagnosis":
      return await updateHlwDiagnosis(item);
    case "addHlwDiagnosis":
      return await addHlwDiagnosis(item);
    case "updateHlwDiagnosisCategory":
      return await updateHlwDiagnosisCategory(item)
  }
};

// 获取诊断列表

async function getDiagnosisList(item) {
  const { name, code, keyword, category } = item;
  try {
    const page = Number.isInteger(item.page) && item.page > 0 ? item.page : 1;
    const pageSize = Number.isInteger(item.pageSize) && item.pageSize > 0 ? item.pageSize : 30;
    // 调用mongo 数据库查询
    let query = {};
    if (Array.isArray(item.ids)) {
      if (item.ids.some(id => typeof id !== 'string')) {
        return { success: false, message: '诊断ID格式错误' };
      }
      const ids = [...new Set(item.ids.map(id => id.trim()))];
      if (ids.some(id => !ObjectId.isValid(id))) {
        return { success: false, message: '诊断ID格式错误' };
      }
      query._id = { $in: ids.map(id => new ObjectId(id)) };
    }
    if (Array.isArray(item.codes)) {
      if (item.codes.some(code => typeof code !== 'string' || !code.trim())) {
        return { success: false, message: '诊断编码格式错误' };
      }
      const codes = [...new Set(item.codes.map(code => code.trim()))];
      query.code = { $in: codes };
    }
    if (name && typeof name === "string") {
      query.name = new RegExp(name.trim(), "i");
    }
    if (code && typeof code === "string") {
      query.code = new RegExp(code.trim(), "i");
    }
    if (category && typeof category === "string") {
      query.category = new RegExp(category.trim(), "i");
    }
    if (typeof keyword == "string" && keyword.trim()) {
      query.$or = [
        { name: new RegExp(keyword.trim(), "i") },
        { code: new RegExp(keyword.trim(), "i") },
        { category: new RegExp(keyword.trim(), "i") },
        { pinyin: new RegExp(keyword.trim(), "i") },
      ];
    }
    const res = await db
      .collection("hlw-diagnosis")
      .find(query)
      .sort({ _id: -1 })
      .skip((page - 1) * pageSize)
      .limit(pageSize)
      .toArray();
    const total = await db.collection("hlw-diagnosis").countDocuments(query);
    return {
      success: true,
      message: "查询成功",
      data: res,
      total,
      pages: Math.ceil(total / pageSize),
    };
  } catch (err) {
    return {
      success: false,
      message: err.message || "查询失败",
    };
  }
}

// 删除诊断信息
async function deleteHlwDiagnosis(item) {
  const { id } = item;
  if (typeof id !== 'string' || id.trim() === '') {
    return { success: false, message: 'id不能为空' }
  }
  try {
    if (!ObjectId.isValid(id.trim())) {
      return { success: false, message: '诊断ID格式错误' }
    }
    const diagnosisId = new ObjectId(id.trim());
    const diagnosis = await db.collection("hlw-diagnosis").findOne(
      { _id: diagnosisId },
      { projection: { _id: 1, code: 1 } }
    );
    if (!diagnosis) {
      return { success: false, message: '未查询到诊断' }
    }
    await ensureApplicableDiagnosisIndexes(db);
    const [hlwDrugCount, onlineDrugCount] = await Promise.all([
      db.collection("drug-info").countDocuments({ applicableDiagnosisCodes: diagnosis.code }, { limit: 1 }),
      db.collection("online-drug-info").countDocuments({ applicableDiagnosisCodes: diagnosis.code }, { limit: 1 }),
    ]);
    if (hlwDrugCount > 0 || onlineDrugCount > 0) {
      return { success: false, message: '该诊断已被药品引用，请先解除关联后再删除' }
    }
    // 调用mongo 数据库删除
    const res = await db.collection("hlw-diagnosis").deleteOne({
      _id: diagnosisId,
    });
    return {
      success: true,
      message: "删除成功",
      res
    };
  } catch (err) {
    return {
      success: false,
      message: err.message || "删除失败",
    };
  }
}

// 更新诊断信息
async function updateHlwDiagnosis(item) {
  if (typeof item.id !== 'string' || item.id.trim() === '') {
    return { success: false, message: 'id不能为空' }
  }
  try {
    // 调用mongo 数据库更新
    const [valid, data] = verifyDisease(item);
    if (!valid) return { success: false, message: data }
    const diagnosisId = new ObjectId(item.id);
    const duplicate = await db.collection("hlw-diagnosis").findOne({
      code: data.code,
      _id: { $ne: diagnosisId },
    }, { projection: { _id: 1 } });
    if (duplicate) return { success: false, message: '诊断编码已存在' }
    data.updateTime = Date.now()
    const res = await db
      .collection("hlw-diagnosis")
      .updateOne(
        { _id: diagnosisId },
        { $set: data }
      );
    if (res.matchedCount === 0) {
      return { success: false, message: '未查询到诊断' }
    }
    return {
      success: true,
      message: "更新成功",
      res
    };
  } catch (err) {
    return {
      success: false,
      message: err.message || "更新失败",
    };
  }
}

async function addHlwDiagnosis(item) {
  try {
    // 调用mongo 数据库新增
    const [valid, data] = verifyDisease(item);
    if (!valid) return { success: false, message: data }
    const duplicate = await db.collection("hlw-diagnosis").findOne(
      { code: data.code },
      { projection: { _id: 1 } }
    );
    if (duplicate) return { success: false, message: '诊断编码已存在' }
    data.createTime = Date.now()
    const res = await db.collection("hlw-diagnosis").insertOne(data);
    return {
      success: true,
      message: "新增成功",
      id: res.insertedId
    };
  } catch (err) {
    return {
      success: false,
      message: err.message || "新增失败",
    };
  }
}

async function updateHlwDiagnosisCategory(ctx) {
  const oldCategory = typeof ctx.oldCategory === 'string' ? ctx.oldCategory.trim() : '';
  const newCategory = typeof ctx.newCategory === 'string' ? ctx.newCategory.trim() : undefined;
  if (!oldCategory || newCategory == undefined) {
    return { success: false, message: '参数有误' }
  }
  try {
    const res = await db.collection("hlw-diagnosis").updateMany(
      { category: oldCategory },
      { $set: { category: newCategory } }
    );
    return {
      success: true,
      message: "更新成功",
      modifiedCount: res.modifiedCount
    };
  } catch (e) {
    return {
      success: false,
      message: e.message || "更新失败",
    };
  }
}


function verifyDisease(ctx) {
  const [valid, name] = validator.verifyString(ctx.name, "诊断名称", 1);
  if (!valid) return [valid, name]
  const [valid1, code] = validator.verifyString(ctx.code, "诊断编码", 1);
  if (!valid1) return [valid1, code]
  const [valid2, pinyin] = validator.verifyString(ctx.pinyin, "诊断拼音码", 1);
  if (!valid2) return [valid2, pinyin]
  const [, category] = validator.verifyString(ctx.category, "常用诊断名");
  return [true, { name, code, pinyin, category }]
}