const { AppError } = require("../utils/AppError");
const { currentDateString, parseDateOnlyString } = require("../utils/date");

const HISTORY_STATUS_VALUES = ["office", "remote", "out", "travel", "leave", "unspecified"];
const PRESENCE_WRITE_STATUS_VALUES = ["office", "remote", "out", "travel"];
const PRESENCE_TIME_RANGE_VALUES = ["full_day", "morning", "afternoon"];
const HISTORY_DEFAULT_DAYS = 7;
const HISTORY_MAX_DAYS = 31;

function buildPresenceValidationError(details, statusCode = 400) {
  return new AppError({
    code: "VALID_001",
    message: "参数校验失败",
    statusCode,
    details,
  });
}

function formatDateOnly(value) {
  if (!value) {
    return null;
  }
  return new Date(`${value.toISOString().slice(0, 10)}T00:00:00.000Z`).toISOString().slice(0, 10);
}

function addUtcDays(date, days) {
  const next = new Date(date.getTime());
  next.setUTCDate(next.getUTCDate() + days);
  return next;
}

function buildDateStrings(dateFrom, dateTo) {
  const items = [];
  for (let current = new Date(dateFrom.getTime()); current <= dateTo; current = addUtcDays(current, 1)) {
    items.push(formatDateOnly(current));
  }
  return items;
}

function resolvePresenceHistoryRange(query, timeZone) {
  const todayString = currentDateString(timeZone ?? "Asia/Shanghai");
  let dateFrom = query.dateFrom ?? null;
  let dateTo = query.dateTo ?? null;

  if (!dateFrom && !dateTo) {
    dateTo = todayString;
    dateFrom = formatDateOnly(addUtcDays(parseDateOnlyString(dateTo), -(HISTORY_DEFAULT_DAYS - 1)));
  } else if (!dateFrom && dateTo) {
    dateFrom = formatDateOnly(addUtcDays(parseDateOnlyString(dateTo), -(HISTORY_DEFAULT_DAYS - 1)));
  } else if (dateFrom && !dateTo) {
    dateTo = todayString;
  }

  const start = parseDateOnlyString(dateFrom);
  const end = parseDateOnlyString(dateTo);
  if (start > end) {
    throw buildPresenceValidationError({ dateTo: "must_be_after_or_equal_dateFrom" });
  }

  const totalDays = Math.floor((end.getTime() - start.getTime()) / 86400000) + 1;
  if (totalDays > HISTORY_MAX_DAYS) {
    throw buildPresenceValidationError({ dateRange: "too_large" });
  }

  return {
    dateFrom,
    dateTo,
    dateStrings: buildDateStrings(start, end),
  };
}

function computeLeaveTimeRange(leave, dateString) {
  const startDate = formatDateOnly(leave.start_date);
  const endDate = formatDateOnly(leave.end_date);
  if (startDate === dateString && endDate === dateString) {
    if (leave.start_session === "pm" && leave.end_session === "pm") return "afternoon";
    if (leave.start_session === "am" && leave.end_session === "am") return "morning";
    return "full_day";
  }
  if (startDate === dateString && leave.start_session === "pm") {
    return "afternoon";
  }
  if (endDate === dateString && leave.end_session === "am") {
    return "morning";
  }
  return "full_day";
}

function mapPresenceRow(row) {
  if (!row) {
    return null;
  }
  return {
    id: row.id,
    employeeId: row.employee_id,
    date: formatDateOnly(row.date),
    status: row.status,
    timeRange: row.time_range,
    note: row.note ?? null,
    source: row.source,
    updatedAt: row.updated_at?.toISOString?.() ?? null,
  };
}

function mapPresenceEmployee(row) {
  return {
    id: row.id,
    employeeNo: row.employee_no,
    name: row.name,
    title: row.title,
    avatarUrl: row.avatar_path ? `/api/avatars/${row.id}` : null,
    employmentStatus: row.employment_status,
    department: row.department ? { id: row.department.id, name: row.department.name } : null,
  };
}

function comparePresenceEmployees(left, right) {
  const departmentCompare = (left.department?.name ?? "").localeCompare(right.department?.name ?? "", "zh-CN");
  if (departmentCompare !== 0) {
    return departmentCompare;
  }
  return left.employeeNo.localeCompare(right.employeeNo, "en");
}

function buildHistoryKey(employeeId, dateString) {
  return `${employeeId}:${dateString}`;
}

function buildTravelPresence(row, dateString) {
  return {
    id: `travel-${row.id}`,
    employeeId: row.applicant_employee_id,
    date: dateString,
    status: "travel",
    timeRange: "full_day",
    note: row.purpose ?? null,
    source: "leave_sync",
    updatedAt: null,
  };
}

function buildLeavePresence(row, dateString) {
  return {
    id: `leave-${row.id}`,
    employeeId: row.owner_id,
    date: dateString,
    status: "leave",
    timeRange: computeLeaveTimeRange(row, dateString),
    note: row.reason ?? null,
    source: "leave_sync",
    updatedAt: null,
  };
}

async function buildPresenceHistoryState(prisma, employeeIds, dateStrings) {
  if (!employeeIds.length || !dateStrings.length) {
    return new Map();
  }

  const dateFrom = dateStrings[0];
  const dateTo = dateStrings[dateStrings.length - 1];
  const [presenceRows, leaveRows, travelRows] = await Promise.all([
    prisma.employeePresence.findMany({
      where: {
        employee_id: { in: employeeIds },
        date: {
          gte: parseDateOnlyString(dateFrom),
          lte: parseDateOnlyString(dateTo),
        },
      },
    }),
    prisma.leaveRequest.findMany({
      where: {
        owner_id: { in: employeeIds },
        status: "approved",
        start_date: { lte: parseDateOnlyString(dateTo) },
        end_date: { gte: parseDateOnlyString(dateFrom) },
      },
      select: {
        id: true,
        owner_id: true,
        start_date: true,
        end_date: true,
        start_session: true,
        end_session: true,
        reason: true,
      },
    }),
    prisma.travelRequest.findMany({
      where: {
        applicant_employee_id: { in: employeeIds },
        status: "approved",
        start_date: { lte: parseDateOnlyString(dateTo) },
        end_date: { gte: parseDateOnlyString(dateFrom) },
      },
      select: {
        id: true,
        applicant_employee_id: true,
        start_date: true,
        end_date: true,
        purpose: true,
      },
    }),
  ]);

  const result = new Map();
  const adminOverrideMap = new Map();
  for (const row of presenceRows) {
    const key = buildHistoryKey(row.employee_id, formatDateOnly(row.date));
    const mapped = mapPresenceRow(row);
    if (row.source === "admin_override") {
      adminOverrideMap.set(key, mapped);
    } else {
      result.set(key, mapped);
    }
  }

  for (const row of travelRows) {
    const startDate = formatDateOnly(row.start_date);
    const endDate = formatDateOnly(row.end_date);
    for (const dateString of dateStrings) {
      if (dateString < startDate || dateString > endDate) {
        continue;
      }
      const key = buildHistoryKey(row.applicant_employee_id, dateString);
      if (!result.has(key) || result.get(key)?.source !== "leave_sync") {
        result.set(key, buildTravelPresence(row, dateString));
      }
    }
  }

  for (const row of leaveRows) {
    const startDate = formatDateOnly(row.start_date);
    const endDate = formatDateOnly(row.end_date);
    for (const dateString of dateStrings) {
      if (dateString < startDate || dateString > endDate) {
        continue;
      }
      const key = buildHistoryKey(row.owner_id, dateString);
      result.set(key, buildLeavePresence(row, dateString));
    }
  }

  for (const [key, value] of adminOverrideMap.entries()) {
    result.set(key, value);
  }

  return result;
}

async function buildPresenceState(prisma, employeeIds, dateString) {
  const historyMap = await buildPresenceHistoryState(prisma, employeeIds, [dateString]);
  const result = new Map();
  for (const employeeId of employeeIds) {
    const key = buildHistoryKey(employeeId, dateString);
    if (historyMap.has(key)) {
      result.set(employeeId, historyMap.get(key));
    }
  }
  return result;
}

async function resolvePresenceForEmployee(prisma, employeeId, dateString) {
  const map = await buildPresenceState(prisma, [employeeId], dateString);
  return map.get(employeeId) ?? null;
}

function buildPresenceSummary(items) {
  const summary = {
    office: 0,
    remote: 0,
    out: 0,
    travel: 0,
    leave: 0,
    unspecified: 0,
    total: items.length,
  };

  for (const item of items) {
    const status = item.presence?.status;
    if (!status || !(status in summary)) {
      summary.unspecified += 1;
      continue;
    }
    summary[status] += 1;
  }

  return summary;
}

function filterHistoryItemsByStatus(items, status) {
  if (!status) {
    return items;
  }
  if (status === "unspecified") {
    return items.filter((item) => !item.presence);
  }
  return items.filter((item) => item.presence?.status === status);
}

async function listActivePresenceEmployees(prisma, filters = {}) {
  const employees = await prisma.employee.findMany({
    where: {
      status: "active",
      ...(filters.departmentId ? { department_id: filters.departmentId } : {}),
      ...(filters.employeeId ? { id: filters.employeeId } : {}),
    },
    select: {
      id: true,
      employee_no: true,
      name: true,
      title: true,
      avatar_path: true,
      employment_status: true,
      department: { select: { id: true, name: true } },
    },
  });

  return employees.map(mapPresenceEmployee).sort(comparePresenceEmployees);
}

function buildTeamHistoryItems(employees, dateStrings, historyMap) {
  return [...dateStrings]
    .reverse()
    .flatMap((date) =>
      employees.map((employee) => ({
        date,
        employee,
        presence: historyMap.get(buildHistoryKey(employee.id, date)) ?? null,
      })),
    );
}

async function buildMyPresenceHistory(prisma, employeeId, dateStrings) {
  const historyMap = await buildPresenceHistoryState(prisma, [employeeId], dateStrings);
  const items = [...dateStrings].reverse().map((date) => ({
    date,
    presence: historyMap.get(buildHistoryKey(employeeId, date)) ?? null,
  }));
  return {
    items,
    summary: buildPresenceSummary(items),
  };
}

async function buildTeamPresenceHistory(prisma, options) {
  const employees = await listActivePresenceEmployees(prisma, {
    departmentId: options.departmentId,
    employeeId: options.employeeId,
  });
  const historyMap = await buildPresenceHistoryState(
    prisma,
    employees.map((item) => item.id),
    options.dateStrings,
  );
  const items = filterHistoryItemsByStatus(
    buildTeamHistoryItems(employees, options.dateStrings, historyMap),
    options.status,
  );

  return {
    employees,
    items,
    summary: buildPresenceSummary(items),
  };
}

async function buildTeamPresenceSummary(prisma, dateString) {
  const employees = await listActivePresenceEmployees(prisma);
  const map = await buildPresenceState(
    prisma,
    employees.map((item) => item.id),
    dateString,
  );
  const items = employees.map((employee) => ({
    employee,
    presence: map.get(employee.id) ?? null,
  }));
  return buildPresenceSummary(items);
}

module.exports = {
  HISTORY_DEFAULT_DAYS,
  HISTORY_MAX_DAYS,
  HISTORY_STATUS_VALUES,
  PRESENCE_TIME_RANGE_VALUES,
  PRESENCE_WRITE_STATUS_VALUES,
  addUtcDays,
  buildHistoryKey,
  buildMyPresenceHistory,
  buildPresenceHistoryState,
  buildPresenceState,
  buildPresenceSummary,
  buildPresenceValidationError,
  buildTeamPresenceHistory,
  buildTeamPresenceSummary,
  filterHistoryItemsByStatus,
  formatDateOnly,
  listActivePresenceEmployees,
  mapPresenceEmployee,
  mapPresenceRow,
  resolvePresenceForEmployee,
  resolvePresenceHistoryRange,
};