// 模拟器官利用数据
const mockOrganUtilizationData = [
  {
    id: 1,
    hospitalNo: "D202312001",
    caseNo: "C202312001",
    donorName: "张三",
    gender: "0",
    age: 45,
    diagnosis: "脑外伤",
    registrant: "李协调员",
    registrationTime: "2023-12-01 15:00:00",
    createTime: "2023-12-01 10:00:00",
    utilizationStatus: "completed",
    completionTime: "2023-12-01 16:30:00",
    isBodyDonation: "1",
    receivingUnit: "医科大学解剖教研室",
    responsibleUserId: "L001",
    coordinatedUserId1: "C001",
    coordinatedUserId2: "C002"
  },
  {
    id: 2,
    hospitalNo: "D202312002",
    caseNo: "C202312002",
    donorName: "李四",
    gender: "1",
    age: 38,
    diagnosis: "心脏骤停",
    registrant: "张协调员",
    registrationTime: "2023-12-02 10:00:00",
    createTime: "2023-12-02 08:30:00",
    utilizationStatus: "in_progress",
    completionTime: "",
    isBodyDonation: "0",
    receivingUnit: "",
    responsibleUserId: "",
    coordinatedUserId1: "",
    coordinatedUserId2: ""
  },
  {
    id: 3,
    hospitalNo: "D202312003",
    caseNo: "C202312003",
    donorName: "王五",
    gender: "0",
    age: 52,
    diagnosis: "脑梗死",
    registrant: "赵协调员",
    registrationTime: "2023-12-03 17:20:00",
    createTime: "2023-12-03 14:00:00",
    utilizationStatus: "pending",
    completionTime: "",
    isBodyDonation: "0",
    receivingUnit: "",
    responsibleUserId: "",
    coordinatedUserId1: "",
    coordinatedUserId2: ""
  }
];

// 模拟器官利用记录数据
const mockUtilizationRecordData = [
  {
    id: 1,
    utilizationId: 1,
    organName: "肝脏",
    organNo: "L001",
    caseNo: "C202312001",
    hospitalNo: "H1001",
    hospitalName: "北京协和医院",
    recipientName: "王",
    transplantDoctor: "张医生",
    transplantTime: "2023-12-01 16:00:00",
    transplantStatus: "1",
    abandonReason: "",
    recipientBirthDate: "1980-05-15",
    recipientGender: "0",
    transplantCenter: "北京协和医院移植中心",
    location: "北京市",
    originalDisease: "肝硬化",
    testIndicators: "肝功能正常，血型匹配"
  },
  {
    id: 2,
    utilizationId: 1,
    organName: "肾脏",
    organNo: "K001",
    caseNo: "C202312001",
    hospitalNo: "H1002",
    hospitalName: "上海瑞金医院",
    recipientName: "李",
    transplantDoctor: "王医生",
    transplantTime: "2023-12-01 16:30:00",
    transplantStatus: "1",
    abandonReason: "",
    recipientBirthDate: "1975-08-20",
    recipientGender: "1",
    transplantCenter: "上海瑞金医院移植中心",
    location: "上海市",
    originalDisease: "尿毒症",
    testIndicators: "肾功能正常，免疫匹配"
  },
  {
    id: 3,
    utilizationId: 1,
    organName: "心脏",
    organNo: "H001",
    caseNo: "C202312001",
    hospitalNo: "H1003",
    hospitalName: "广州中山医院",
    recipientName: "陈",
    transplantDoctor: "刘医生",
    transplantTime: "2023-12-01 17:00:00",
    transplantStatus: "1",
    abandonReason: "",
    recipientBirthDate: "1982-03-10",
    recipientGender: "0",
    transplantCenter: "广州中山医院心脏中心",
    location: "广州市",
    originalDisease: "心肌病",
    testIndicators: "心功能正常，血型匹配"
  }
];

// 模拟随访记录数据
const mockFollowupRecordData = [
  {
    id: 1,
    utilizationId: 1,
    organNo: "L001",
    followupTime: "2024-01-01 10:00:00",
    followupType: "routine",
    recipientCondition: "恢复良好，肝功能正常",
    medicationSituation: "免疫抑制剂规律服用",
    testResults: "肝功能指标正常，血药浓度达标",
    nextFollowupTime: "2024-04-01",
    followupDoctor: "张医生",
    attachment: "肝功能检查报告.pdf"
  },
  {
    id: 2,
    utilizationId: 1,
    organNo: "K001",
    followupTime: "2024-01-02 09:30:00",
    followupType: "routine",
    recipientCondition: "肾功能稳定，无排斥反应",
    medicationSituation: "抗排斥药物按时服用",
    testResults: "肌酐水平正常，尿常规无异常",
    nextFollowupTime: "2024-04-02",
    followupDoctor: "王医生",
    attachment: "肾功能随访报告.pdf"
  },
  {
    id: 3,
    utilizationId: 1,
    organNo: "H001",
    followupTime: "2024-01-03 11:00:00",
    followupType: "emergency",
    recipientCondition: "出现轻微排斥反应，已处理",
    medicationSituation: "调整免疫抑制剂剂量",
    testResults: "心功能指标基本正常，需密切观察",
    nextFollowupTime: "2024-01-10",
    followupDoctor: "刘医生",
    attachment: "心脏移植随访记录.pdf"
  }
];

// 模拟医院数据
const mockHospitalData = [
  { id: 1, hospitalNo: "H1001", hospitalName: "北京协和医院", type: "4" },
  { id: 2, hospitalNo: "H1002", hospitalName: "上海瑞金医院", type: "4" },
  { id: 3, hospitalNo: "H1003", hospitalName: "广州中山医院", type: "4" }
];

// 模拟负责人数据
const mockLeaderData = [
  { reportNo: "L001", reportName: "张主任" },
  { reportNo: "L002", reportName: "王主任" },
  { reportNo: "L003", reportName: "李主任" }
];

// 模拟协调员数据
const mockCoordinatorData = [
  { reportNo: "C001", reportName: "张协调员" },
  { reportNo: "C002", reportName: "李协调员" },
  { reportNo: "C003", reportName: "王协调员" },
  { reportNo: "C004", reportName: "赵协调员" }
];

// 模拟API响应延迟
const delay = (ms = 500) => new Promise(resolve => setTimeout(resolve, ms));

// 查询器官利用列表
export const listOrganUtilization = async (queryParams = {}) => {
  await delay();

  const {
    pageNum = 1,
    pageSize = 10,
    hospitalNo,
    donorName,
    utilizationStatus
  } = queryParams;

  // 过滤数据
  let filteredData = mockOrganUtilizationData.filter(item => {
    let match = true;

    if (hospitalNo && !item.hospitalNo.includes(hospitalNo)) {
      match = false;
    }

    if (donorName && !item.donorName.includes(donorName)) {
      match = false;
    }

    if (utilizationStatus && item.utilizationStatus !== utilizationStatus) {
      match = false;
    }

    return match;
  });

  // 分页
  const startIndex = (pageNum - 1) * pageSize;
  const endIndex = startIndex + parseInt(pageSize);
  const paginatedData = filteredData.slice(startIndex, endIndex);

  return {
    code: 200,
    message: "success",
    data: {
      rows: paginatedData,
      total: filteredData.length,
      pageNum: parseInt(pageNum),
      pageSize: parseInt(pageSize)
    }
  };
};

// 获取器官利用详细信息
export const getOrganUtilizationDetail = async (id) => {
  await delay();

  const detail = mockOrganUtilizationData.find(item => item.id == id);

  if (detail) {
    // 获取利用记录
    const utilizationRecords = mockUtilizationRecordData.filter(item => item.utilizationId == id);
    // 获取随访记录
    const followupRecords = mockFollowupRecordData.filter(item => item.utilizationId == id);

    return {
      code: 200,
      message: "success",
      data: {
        ...detail,
        utilizationRecords,
        followupRecords
      }
    };
  } else {
    return {
      code: 404,
      message: "器官利用记录不存在"
    };
  }
};

// 新增器官利用
export const addOrganUtilization = async (data) => {
  await delay();

  const newId = Math.max(...mockOrganUtilizationData.map(item => item.id), 0) + 1;
  const hospitalNo = `D${new Date().getFullYear()}${String(new Date().getMonth() + 1).padStart(2, '0')}${String(newId).padStart(3, '0')}`;
  const caseNo = `C${new Date().getFullYear()}${String(new Date().getMonth() + 1).padStart(2, '0')}${String(newId).padStart(3, '0')}`;

  const newRecord = {
    ...data,
    id: newId,
    hospitalNo,
    caseNo,
    registrationTime: new Date().toISOString().replace('T', ' ').substring(0, 19),
    createTime: new Date().toISOString().replace('T', ' ').substring(0, 19)
  };

  mockOrganUtilizationData.unshift(newRecord);

  return {
    code: 200,
    message: "新增成功",
    data: newRecord
  };
};

// 修改器官利用
export const updateOrganUtilization = async (data) => {
  await delay();

  const index = mockOrganUtilizationData.findIndex(item => item.id == data.id);

  if (index !== -1) {
    mockOrganUtilizationData[index] = {
      ...mockOrganUtilizationData[index],
      ...data,
      updateTime: new Date().toISOString().replace('T', ' ').substring(0, 19)
    };

    return {
      code: 200,
      message: "修改成功",
      data: mockOrganUtilizationData[index]
    };
  } else {
    return {
      code: 404,
      message: "器官利用记录不存在"
    };
  }
};

// 删除器官利用
export const delOrganUtilization = async (ids) => {
  await delay();

  const idArray = Array.isArray(ids) ? ids : [ids];

  idArray.forEach(id => {
    const index = mockOrganUtilizationData.findIndex(item => item.id == id);
    if (index !== -1) {
      mockOrganUtilizationData.splice(index, 1);
    }
  });

  return {
    code: 200,
    message: "删除成功"
  };
};

// 保存器官利用记录
export const saveUtilizationRecords = async (utilizationId, records) => {
  await delay();

  // 删除该利用ID的所有记录
  const existingIndexes = [];
  mockUtilizationRecordData.forEach((item, index) => {
    if (item.utilizationId == utilizationId) {
      existingIndexes.push(index);
    }
  });

  // 从后往前删除避免索引问题
  existingIndexes.reverse().forEach(index => {
    mockUtilizationRecordData.splice(index, 1);
  });

  // 添加新记录
  records.forEach(record => {
    const newId = Math.max(...mockUtilizationRecordData.map(item => item.id), 0) + 1;
    mockUtilizationRecordData.push({
      ...record,
      id: newId,
      utilizationId: utilizationId
    });
  });

  return {
    code: 200,
    message: "保存成功",
    data: records
  };
};

// 保存随访记录
export const saveFollowupRecord = async (record) => {
  await delay();

  const newId = Math.max(...mockFollowupRecordData.map(item => item.id), 0) + 1;
  const newRecord = {
    ...record,
    id: newId
  };

  mockFollowupRecordData.push(newRecord);

  return {
    code: 200,
    message: "随访记录保存成功",
    data: newRecord
  };
};

// 获取医院列表
export const getHospitalList = async () => {
  await delay();

  return {
    code: 200,
    message: "success",
    data: mockHospitalData
  };
};

// 获取负责人列表
export const getLeaderList = async () => {
  await delay();

  return {
    code: 200,
    message: "success",
    data: mockLeaderData
  };
};

// 获取协调员列表
export const getCoordinatorList = async () => {
  await delay();

  return {
    code: 200,
    message: "success",
    data: mockCoordinatorData
  };
};

export default {
  listOrganUtilization,
  getOrganUtilizationDetail,
  addOrganUtilization,
  updateOrganUtilization,
  delOrganUtilization,
  saveUtilizationRecords,
  saveFollowupRecord,
  getHospitalList,
  getLeaderList,
  getCoordinatorList
};