let dayjs = require("dayjs");
let utils = require("../utils.js");
const api = require("../../api");

let db = null;

exports.main = async (content, DB) => {
  db = DB;
  switch (content.type) {
    case "getCustomerStatistics":
      return await exports.getCustomerStatistics(content);
    case "getServiceAndmemberTotalByTeamId":
      return await exports.getServiceAndmemberTotalByTeamId(content);
    case "getServiceAndmemberTotalByUserId":
      return await exports.getServiceAndmemberTotalByUserId(content);
    case "getServiceTrendByTeamId":
      return await exports.getServiceTrendByTeamId(content);
    case "getMemberTrendByTeamId":
      return await exports.getMemberTrendByTeamId(content);
    case "getUsersMemberByTeamId":
      return await exports.getUsersMemberByTeamId(content);
    case "getTeamsServiceAndMemberCount":
      return await getTeamsServiceAndMemberCount(content);
    case "getStaffServiceAndMemberCount":
      return await getStaffServiceAndMemberCount(content);
    case "getCustomerSourceCountSort":
      return await getCustomerSourceCountSort(content);
    case "getCustomerGroupCountSort":
      return await getCustomerGroupCountSort(content);
    case "getCusomterAndServiceCount":
      return await getCusomterAndServiceCount(content);
    case "getStaffRate":
      return await getStaffRate(content);
    case "getScoreRateTrend":
      return await getScoreRateTrend(content);
    case "getTeamCustmerCount":
      return await getTeamCustmerCount(content);
  }
};

// 获取客户数和服务数
async function getCusomterAndServiceCount(content) {
  const { corpId } = content;
  const todayStartTime = dayjs().startOf("day").valueOf();
  const todayEndTime = dayjs().endOf("day").valueOf();
  // 获取客户总数
  const customerTotalCount = await db
    .collection("member")
    .find({ corpId })
    .count();
  const serviceTotalCount = await db
    .collection("service-record")
    .find({ corpId, eventType: { $ne: "serviceRate" } })
    .count();
  let todayCustomerCount = await db
    .collection("member")
    .find({
      corpId,
      createTime: { $gte: todayStartTime, $lt: todayEndTime },
    })
    .count();
  let todayServiceCount = await db
    .collection("service-record")
    .find({
      corpId,
      eventType: { $ne: "serviceRate" },
      createTime: { $gte: todayStartTime, $lt: todayEndTime },
    })
    .count();
  return {
    success: true,
    message: "获取成功",
    customerTotalCount,
    serviceTotalCount,
    todayCustomerCount,
    todayServiceCount,
  };
}

// 分组客户数据统计
async function getCustomerGroupCountSort(content) {
  const { corpId } = content;
  const data = await db
    .collection("member")
    .aggregate([
      { $match: { corpId } },
      { $group: { _id: "$groupIds", count: { $sum: 1 } } },
    ])
    .toArray();
  const result = data.reduce((acc, item) => {
    if (Array.isArray(item._id)) {
      item._id.forEach((id) => {
        acc[id] = (acc[id] || 0) + item.count;
      });
    } else if (item._id) {
      acc[item._id] = (acc[item._id] || 0) + item.count;
    }
    return acc;
  }, {});
  let list = Object.entries(result).map(([groupId, count]) => ({
    groupId,
    count,
  }));
  const ids = list.map((item) => item.groupId);
  let res = await db
    .collection("group")
    .find({ _id: { $in: ids } })
    .limit(1000)
    .toArray();
  list = list.map((item) => {
    let group = res.find((i) => i._id === item.groupId);
    if (!group) {
      return {
        ...item,
        groupName: "未知",
      };
    } else {
      return {
        ...item,
        groupName: group.groupName,
        parentGroupId: group.parentGroupId,
      };
    }
  });
  list = list.filter((i) => i.groupName !== "未知");
  let mergedList = [];
  list.forEach((item) => {
    if (!item.parentGroupId) {
      mergedList.push(item);
      return;
    }
    let existingItem = mergedList.find(
      (el) => el.parentGroupId === item.parentGroupId
    );
    if (existingItem) {
      existingItem.count += item.count;
    } else {
      mergedList.push(item);
    }
  });
  mergedList.sort((a, b) => b.count - a.count);
  let countAfterFive = 0;
  if (mergedList.length > 5) {
    for (let i = 5; i < mergedList.length; i++) {
      countAfterFive += mergedList[i].count;
    }
    mergedList = mergedList.slice(0, 5);
    mergedList.push({
      groupName: "其他",
      count: countAfterFive,
    });
  }
  return {
    success: true,
    message: "获取成功",
    list: mergedList,
  };
}

// 获取获取客户来源的客户数据
async function getCustomerSourceCountSort(content) {
  const { corpId, sources = [] } = content;
  const PAGE_SIZE = 1000; // 每页查询的记录数，可以根据实际情况调整
  let page = 0;
  let hasMoreData = true;
  let allData = [];

  while (hasMoreData) {
    const data = await db
      .collection("member")
      .aggregate([
        { $match: { corpId } },
        { $skip: page * PAGE_SIZE },
        { $limit: PAGE_SIZE },
        { $group: { _id: "$customerSource", count: { $sum: 1 } } },
      ])
      .toArray();

    if (data.length > 0) {
      allData = allData.concat(data);
      page++;
    } else {
      hasMoreData = false; // 如果没有更多数据，停止查询
    }
  }

  // 处理数据
  const result = allData.reduce((acc, item) => {
    if (Array.isArray(item._id)) {
      item._id.forEach((id) => {
        acc[id] = (acc[id] || 0) + item.count;
      });
    } else if (item._id) {
      acc[item._id] = (acc[item._id] || 0) + item.count;
    }
    return acc;
  }, {});

  // 获取未知来源的数据
  let unknowSourceCount = allData.find((i) => !i._id)
    ? allData.find((i) => !i._id).count
    : 0;

  let list = Object.entries(result)
    .map(([sourceName, count]) => ({
      sourceName,
      count,
    }))
    .filter((i) => sources.some((item) => item === i.sourceName));

  list.sort((a, b) => b.count - a.count);

  if (list.length > 5) {
    // 5名之后相加
    let countAfterFive = 0;
    for (let i = 5; i < list.length; i++) {
      countAfterFive += list[i].count;
    }
    list = list.slice(0, 5);
    list.push({
      sourceName: "其他",
      count: countAfterFive,
    });
  }

  list.push({
    sourceName: "未知",
    count: unknowSourceCount,
  });

  return {
    success: true,
    message: "获取成功",
    data: allData,
    list,
  };
}

//获取团队服务和客户总数
async function getTeamsServiceAndMemberCount(context) {
  try {
    const { corpId, dates } = context;
    let teamList = await getCorpTeams(corpId);
    teamList = teamList.map((item) => {
      return {
        ...item,
        corpId,
        dates,
      };
    });
    const handler = async (item) => {
      let { data } = await exports.getServiceAndmemberTotalByTeamId(item);
      let { averageScore } = await getStaffRate(item);
      return {
        ...data,
        satisfaction: averageScore,
      };
    };
    let list = await utils.processInBatches(teamList, handler, 10);
    return {
      success: true,
      message: "获取成功",
      list,
    };
  } catch (e) {
    return { success: false, message: e.message };
  }
}

// 获取满意度评分趋势
async function getScoreRateTrend(context) {
  const { corpId, dates } = context;
  const { startTime, lastTime } = getStartAndEndTime(dates);
  let params = {
    corpId,
  };
  if (dates && Array.isArray(dates) && dates.length !== 0) {
    params["createTime"] = { $gte: startTime, $lte: lastTime };
  }
  // 已评价的总数
  let ratedTotalCount = await db
    .collection("corp-rate-records")
    .find({ ...params, rate: { $exists: true } })
    .count();
  // 未评价的总数
  let unratedTotalCount = await db
    .collection("corp-rate-records")
    .find({
      ...params,
      rate: { $exists: false },
      expireTime: { $lte: new Date().getTime() },
    })
    .count();

  const getRateCount = async (rate) => {
    return await db
      .collection("corp-rate-records")
      .find({ ...params, rate })
      .count();
  };
  let arrCount = Promise.all([
    getRateCount(5),
    getRateCount(4),
    getRateCount(3),
    getRateCount(2),
    getRateCount(1),
  ]);
  let [
    fiveStarCount,
    fourStarCount,
    threeStarCount,
    twoStarCount,
    oneStareCount,
  ] = await arrCount;
  return {
    success: true,
    message: "获取成功",
    count: {
      total: ratedTotalCount + unratedTotalCount,
      fiveStarCount: fiveStarCount + unratedTotalCount,
      fourStarCount,
      threeStarCount,
      twoStarCount,
      oneStareCount,
    },
  };
}

// 获取员工服务满意度评分
async function getStaffRate(context) {
  const { corpId, dates, userId, teamId } = context;
  const { startTime, lastTime } = getStartAndEndTime(dates);
  const rateQuery = { corpId, teamId };
  if (userId) rateQuery.userId = userId;
  if (dates && Array.isArray(dates) && dates.length !== 0) {
    rateQuery["createTime"] = { $gte: startTime, $lte: lastTime };
  }
  // 获取 4 5星评价的条数
  const goodRateCout = await api.getKnowledgeBaseApi({
    type: "getRateRecordCount",
    params: { ...rateQuery, rate: { $in: [4, 5] } },
    corpId,
  });
  // 获取 1 2 3星评价的条数
  const notGoodRateCout = await api.getKnowledgeBaseApi({
    type: "getRateRecordCount",
    params: { ...rateQuery, rate: { $in: [1, 2, 3] } },
    corpId,
  });
  // 获取超时未评价的条数 （超时未评价默认好评）
  const unratedCount = await api.getKnowledgeBaseApi({
    type: "getRateRecordCount",
    params: {
      ...rateQuery,
      rate: { $exists: false },
      expireTime: { $lte: new Date().getTime() },
    },
    corpId,
  });
  const rate =
    (goodRateCout + unratedCount) /
    Math.max(goodRateCout + notGoodRateCout + unratedCount, 1);
  const percent = (rate * 100).toFixed(2);
  return {
    success: true,
    message: "获取成功",
    averageScore: percent,
  };
}

async function getStaffServiceAndMemberCount(context) {
  const { corpId, dates } = context;
  let staffList = await getCorpStaffs(corpId);
  staffList = staffList.map((item) => {
    return {
      userId: item.userid,
      corpId,
      dates,
    };
  });
  const handler = async (item) => {
    let { data } = await exports.getServiceAndmemberTotalByUserId(item);
    let { averageScore } = await getStaffRate(item);
    return {
      ...data,
      satisfaction: averageScore,
    };
  };
  let list = await utils.processInBatches(staffList, handler, 10);
  return {
    success: true,
    message: "获取成功",
    list,
  };
}

exports.getServiceAndmemberTotalByTeamId = async (context) => {
  const { corpId, teamId, dates, name } = context;
  const { startTime, lastTime } = getStartAndEndTime(dates);
  let memberParmas = {
    corpId,
    teamId,
  };
  let serviceParams = {
    corpId,
    executeTeamId: teamId,
    eventType: { $ne: "serviceRate" },
  };
  let registrationParams = {
    teamId,
  };
  if (Array.isArray(dates) && dates.length !== 0) {
    memberParmas["createTime"] = { $gte: startTime, $lte: lastTime };
    serviceParams["executionTime"] = { $gte: startTime, $lte: lastTime };
    registrationParams["createTime"] = { $gte: startTime, $lte: lastTime };
  }
  try {
    let memberCount = await db.collection("member").find(memberParmas).count();
    let serviceCount = await db
      .collection("service-record")
      .find(serviceParams)
      .count();
    let visitCount = await db
      .collection("registration")
      .find(registrationParams)
      .count();
    return {
      success: true,
      message: "获取成功",
      data: {
        memberCount,
        serviceCount,
        visitCount,
        teamName: name,
      },
    };
  } catch {
    return {
      success: false,
      message: "获取失败",
    };
  }
};

exports.getServiceAndmemberTotalByUserId = async (context) => {
  const { corpId, userId, dates } = context;
  const { startTime, lastTime } = getStartAndEndTime(dates);

  try {
    let memberParams = {
      corpId,
      personResponsibles: { $elemMatch: { corpUserId: userId } },
    };
    let serviceParams = {
      corpId,
      executorUserId: userId,
      eventType: { $ne: "serviceRate" },
    };
    if (Array.isArray(dates) && dates.length !== 0) {
      memberParams["createTime"] = { $gte: startTime, $lte: lastTime };
      serviceParams["executionTime"] = { $gte: startTime, $lte: lastTime };
    }
    let memberCount = await db.collection("member").find(memberParams).count();
    let serviceCount = await db
      .collection("service-record")
      .find(serviceParams)
      .count();
    let res = await db
      .collection("member")
      .find(memberParams)
      .project({
        name: 1,
        _id: 1,
        personResponsibles: 1,
      })
      .toArray();
    return {
      success: true,
      message: "获取成功",
      data: {
        memberCount,
        serviceCount,
        userId,
        res,
      },
    };
  } catch {
    return {
      success: false,
      message: "获取失败",
    };
  }
};

// 获取所有团队
async function getCorpTeams(corpId) {
  const fetchData = async (page, pageSize, db) => {
    const { list = [] } = await api.getCorpApi({
      type: "getCorpTeams",
      corpId,
      pageSize,
      page,
      fields: { name: 1, teamId: 1 },
      showCustomerCount: false,
    });
    return Array.isArray(list) ? list : [];
  };

  const list = await utils.getAllData(fetchData, db);
  return list;
}

// 获取所有成员
async function getCorpStaffs(corpId) {
  const fetchData = async (page, pageSize, db) => {
    const { data } = await api.getCorpApi({
      type: 'getCorpMember',
      page,
      pageSize,
      params: { corpId, open_userid: { $exists: true } }
    })
    const list = Array.isArray(data) ? data.map(i => ({ userid: i.userid })).filter(i => i.userid) : [];
    return list;
  };
  const list = await utils.getAllData(fetchData, db);
  return list;
}

exports.getCustomerStatistics = async (content) => {
  const { corpId } = content;
  // 校验 corpId 是否存在
  if (!corpId) {
    return {
      success: false,
      message: "机构id不能为空",
    };
  }

  try {
    // 获取今日的起始和结束时间戳
    const todayStartTime = dayjs().startOf("day").valueOf();
    const todayEndTime = dayjs().endOf("day").valueOf();

    // 使用聚合管道来进行多个统计查询
    const result = await db
      .collection("member")
      .aggregate([
        {
          $match: { corpId },
        },
        {
          $facet: {
            // 获取客户总数
            totalCount: [{ $count: "total" }],
            // 获取已加好友数
            friendCount: [
              { $match: { externalUserId: { $ne: "", $exists: true } } },
              { $count: "total" },
            ],
            // 获取未加好友数
            noFriendCount: [
              {
                $match: {
                  $or: [
                    { externalUserId: { $eq: "" } },
                    { externalUserId: { $exists: false } },
                  ],
                },
              },
              { $count: "total" },
            ],
            // 获取今日新增客户数
            todayAddCustomerCount: [
              {
                $match: {
                  createTime: { $gte: todayStartTime, $lt: todayEndTime },
                },
              },
              { $count: "total" },
            ],
            // 获取今日新增好友数
            todayAddFriendCount: [
              {
                $match: {
                  externalUserId: { $ne: "", $exists: true },
                  createTime: { $gte: todayStartTime, $lt: todayEndTime },
                },
              },
              { $count: "total" },
            ],
            // 获取今日未加好友数
            todayNoFriendCount: [
              {
                $match: {
                  $or: [
                    { externalUserId: { $eq: "" } },
                    { externalUserId: { $exists: false } },
                  ],
                  createTime: { $gte: todayStartTime, $lt: todayEndTime },
                },
              },
              { $count: "total" },
            ],
          },
        },
        {
          $project: {
            customerTotalCount: { $arrayElemAt: ["$totalCount.total", 0] },
            friendCount: { $arrayElemAt: ["$friendCount.total", 0] },
            noFriendCount: { $arrayElemAt: ["$noFriendCount.total", 0] },
            todayAddCustomerCount: {
              $arrayElemAt: ["$todayAddCustomerCount.total", 0],
            },
            todayAddFriendCount: {
              $arrayElemAt: ["$todayAddFriendCount.total", 0],
            },
            todayNoFriendCount: {
              $arrayElemAt: ["$todayNoFriendCount.total", 0],
            },
          },
        },
      ])
      .toArray();

    // 处理返回的数据，将缺失的字段赋值为 0
    const stats = result[0] || {};
    return {
      success: true,
      message: "获取成功",
      data: {
        customerTotalCount: stats.customerTotalCount || 0,
        friendCount: stats.friendCount || 0,
        noFriendCount: stats.noFriendCount || 0,
        todayAddCustomerCount: stats.todayAddCustomerCount || 0,
        todayAddFriendCount: stats.todayAddFriendCount || 0,
        todayNoFriendCount: stats.todayNoFriendCount || 0,
      },
    };
  } catch (error) {
    return {
      success: false,
      message: "获取失败",
    };
  }
};

function getStartAndEndTime(dates) {
  if (!dates || dates.length === 0) {
    return {
      startTime: "",
      lastTime: "",
    };
  }
  let t_1 = dates[0];
  let t_2 = dates[1];
  return {
    startTime: t_1 && new Date(t_1).setHours(0, 0, 0, 0),
    lastTime: t_2 && new Date(t_2).setHours(23, 59, 59, 999),
  };
}

exports.getMemberTrendByTeamId = async (context) => {
  const { corpId, teamId, dates, userId, dataType = "increaseCount" } = context;
  const { startTime, lastTime } = getStartAndEndTime(dates);
  let params = {
    createTime: { $gte: startTime, $lte: lastTime },
  };
  try {
    let result = {};
    if (dataType === "increaseCount") {
      if (userId) {
        params["personResponsibles"] = {
          $elemMatch: { corpUserId: userId, teamId: teamId },
        };
      }
      params["corpId"] = corpId;
      params["teamId"] = teamId;
      result = await db
        .collection("member")
        .aggregate([
          { $match: params },
          {
            $group: {
              _id: {
                $dateToString: {
                  format: "%Y-%m-%d",
                  date: { $toDate: "$createTime" },
                },
              },
              count: { $sum: 1 },
            },
          },
        ])
        .toArray();
    } else if (dataType === "visitCount") {
      params["teamId"] = teamId;
      result = await db
        .collection("registration")
        .aggregate([
          { $match: params },
          {
            $group: {
              _id: {
                $dateToString: {
                  format: "%Y-%m-%d",
                  date: { $toDate: "$createTime" },
                },
              },
              count: { $sum: 1 },
            },
          },
        ])
        .toArray();
    } else if (dataType === "peopleCount") {
      params["corpId"] = corpId;
      params["executeTeamId"] = teamId;
      if (userId) params["creatorUserId"] = userId;
      result = await db
        .collection("service-record")
        .aggregate([
          { $match: params },
          {
            $group: {
              _id: {
                $dateToString: {
                  format: "%Y-%m-%d",
                  date: { $toDate: "$createTime" },
                },
              },
              count: { $sum: 1 },
            },
          },
        ])
        .toArray();
    }
    let list = result;
    let filledArray = fillDateGaps(list, dates[0], dates[1]);
    return {
      success: true,
      message: "获取成功",
      data: filledArray,
    };
  } catch (error) {
    return {
      success: false,
      message: "获取失败",
    };
  }
};

exports.getServiceTrendByTeamId = async (context) => {
  const { corpId, teamId, userId, dates } = context;
  const { startTime, lastTime } = getStartAndEndTime(dates);
  let params = {
    corpId,
    executeTeamId: teamId,
    createTime: { $gte: startTime, $lte: lastTime },
  };
  if (userId) {
    params["executorUserId"] = userId;
  }
  try {
    const result = await db
      .collection("service-record")
      .aggregate([
        { $match: params },
        {
          $group: {
            _id: {
              $dateToString: {
                format: "%Y-%m-%d",
                date: { $toDate: "$createTime" },
              },
            },
            count: { $sum: 1 },
          },
        },
      ])
      .toArray();
    let list = result;
    let filledArray = fillDateGaps(list, dates[0], dates[1]);
    return {
      success: true,
      message: "获取成功",
      data: filledArray,
      params,
    };
  } catch (error) {
    return {
      success: false,
      message: "获取失败",
    };
  }
};

// 获取团队成员客户数
exports.getUsersMemberByTeamId = async (context) => {
  try {
    const { memberList } = context;
    let counts = [];
    let arr = memberList.map((i) => {
      return getServiceAndMemberCount(context, i);
    });
    for (let i = 0; i < arr.length; i += 10) {
      const promiseArr = arr.slice(i, i + 10);
      const list = await Promise.all(promiseArr);
      counts = counts.concat(list);
    }
    return {
      success: true,
      message: "获取成功",
      data: counts,
    };
  } catch (error) {
    return {
      success: false,
      message: "获取失败",
    };
  }
};

async function getServiceAndMemberCount(context, userId) {
  const { corpId, teamId, dates } = context;
  const { startTime, lastTime } = getStartAndEndTime(dates);
  const query = {
    teamId,
    personResponsibles: { $elemMatch: { corpUserId: userId, teamId } },
    createTime: { $gte: startTime, $lte: lastTime },
  };
  let servicQuery = {
    corpId,
    createTime: { $gte: startTime, $lte: lastTime },
    executorUserId: userId,
    executeTeamId: teamId,
    eventType: { $ne: "serviceRate" },
  };

  const customerCount = await db
    .collection("member")
    .find({ ...query, corpId })
    .count();
  const visitCount = await db.collection("registration").find(query).count();
  const serviceCount = await db
    .collection("service-record")
    .find(servicQuery)
    .count();
  return {
    userId,
    customerCount,
    visitCount,
    serviceCount,
  };
}

// 填充日期间隔
function fillDateGaps(arr, start, end) {
  let startDate = new Date(start);
  let endDate = new Date(end);

  let dateCounts = {};

  arr.forEach((item) => {
    dateCounts[item._id] = item.count;
  });

  while (startDate <= endDate) {
    let dateString = startDate.toISOString().split("T")[0];
    if (!dateCounts[dateString]) {
      dateCounts[dateString] = 0;
    }
    startDate.setDate(startDate.getDate() + 1);
  }

  let datesArray = Object.entries(dateCounts).map(([dateString, count]) => {
    return { _id: dateString, count: count };
  });

  datesArray.sort((a, b) => new Date(a._id) - new Date(b._id));

  return datesArray;
}

async function getTeamCustmerCount(ctx) {
  const { corpId, teamIds } = ctx;
  if (!corpId || !Array.isArray(teamIds) || teamIds.length === 0) {
    return [];
  }
  try {
    const customerCounts = await db
      .collection("member")
      .aggregate([
        { $match: { teamId: { $in: teamIds } } }, // 查找 teamId 数组中包含任意 teamId 的文档
        { $unwind: "$teamId" }, // 展开 teamId 数组，每个 teamId 成为一个单独的文档
        { $match: { teamId: { $in: teamIds } } }, // 再次匹配这些 teamId 是否在目标队列中
        {
          $group: {
            _id: "$teamId", // 根据 teamId 聚合
            count: { $sum: 1 }, // 计算每个 teamId 的数量
          },
        },
      ])
      .toArray();
    return customerCounts;
  } catch (e) {
    return [];
  }
}