import { Injectable, Logger } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository, In } from 'typeorm';
import {
  ClassSchedule,
  ClassStudent,
  StudentDingMapping,
  Class,
} from '../entities';
import { DingTalkService, DingTalkScheduleItem } from '../integration/dingtalk.service';

/** 单次排班同步的结果 */
export interface ScheduleSyncResult {
  /** 参与同步的排课记录数 */
  scheduleCount: number;
  /** 创建/复用的班次数 */
  shiftCount: number;
  /** 创建/复用的考勤组数 */
  groupCount: number;
  /** 实际写入钉钉的排班条数 */
  syncedItems: number;
  /** 因无学生或无钉钉映射而跳过的排课数 */
  skippedNoMapping: number;
  /** 按班级分组的详情 */
  groups: Array<{
    className: string;
    groupId: number;
    itemCount: number;
  }>;
}

/**
 * 排班同步服务 — 将本地 ClassSchedule 同步到钉钉考勤排班。
 *
 * ## 同步流程（按班级学生）
 * 1. 查询活跃排课，按 classId 分组
 * 2. 通过 ClassStudent + StudentDingMapping 拿到每个班级学生的钉钉 userId
 * 3. 按 (startTime, endTime) 创建/匹配钉钉班次（班次列表只拉一次）
 * 4. 每个班级创建/匹配一个排班制考勤组（考勤组列表只拉一次）
 * 5. 将排课展开为每个学生的每日排班，批量写入钉钉
 *
 * ## API 调用优化
 * - 班次列表、考勤组列表各只查询一次，在内存中按名称匹配，避免每次 findOrCreate 都发一次查询。
 * - 排班写入按考勤组分批（钉钉单次最多 200 条）。
 */
@Injectable()
export class ScheduleSyncService {
  private readonly logger = new Logger(ScheduleSyncService.name);

  constructor(
    @InjectRepository(ClassSchedule)
    private readonly scheduleRepo: Repository<ClassSchedule>,
    @InjectRepository(ClassStudent)
    private readonly classStudentRepo: Repository<ClassStudent>,
    @InjectRepository(StudentDingMapping)
    private readonly mappingRepo: Repository<StudentDingMapping>,
    @InjectRepository(Class)
    private readonly classRepo: Repository<Class>,
    private readonly dingTalkService: DingTalkService,
  ) {}

  /**
   * 全量同步：将所有活跃排课同步到钉钉排班。
   * @param dateFrom 起始日期（YYYY-MM-DD），默认今天
   * @param days 同步天数，默认 30
   * @param opUserId 钉钉操作人 userId
   */
  async syncAll(
    dateFrom?: string,
    days = 30,
    opUserId = 'manager',
  ): Promise<ScheduleSyncResult> {
    const startDate = dateFrom || new Date().toISOString().slice(0, 10);
    const endDate = this.addDays(startDate, days);

    const empty: ScheduleSyncResult = {
      scheduleCount: 0, shiftCount: 0, groupCount: 0,
      syncedItems: 0, skippedNoMapping: 0, groups: [],
    };

    // ── Step 1: 查询活跃排课（必须关联到班级才能取学生） ──
    const allSchedules = await this.scheduleRepo.find({
      where: { status: 'active' },
    });
    const schedules = allSchedules.filter((s) => s.classId != null);
    if (schedules.length === 0) {
      this.logger.log('没有需要同步的活跃排课（无关联班级）');
      return empty;
    }

    // ── Step 2: 班级 → 学生钉钉ID 映射 ──
    const classIds = [...new Set(schedules.map((s) => s.classId as number))];
    const classDingUsers = await this.buildClassDingUserMap(classIds);

    // ── Step 3: 班次（按时间段去重，班次列表只查一次） ──
    const shiftKey = (start: string, end: string) => `${start}-${end}`;
    const uniqueShifts = new Map<string, { startTime: string; endTime: string }>();
    for (const s of schedules) {
      const key = shiftKey(s.startTime, s.endTime);
      if (!uniqueShifts.has(key)) {
        uniqueShifts.set(key, { startTime: s.startTime, endTime: s.endTime });
      }
    }

    const existingShifts = await this.dingTalkService.queryShifts(opUserId);
    const shiftByName = new Map(existingShifts.map((s) => [s.name, s.id]));
    const timeToShiftId = new Map<string, number>();
    let shiftCount = 0;
    for (const [key, { startTime, endTime }] of uniqueShifts) {
      const shiftName = `排课_${startTime}-${endTime}`;
      try {
        let shiftId = shiftByName.get(shiftName);
        if (shiftId === undefined) {
          shiftId = await this.dingTalkService.upsertShift({
            name: shiftName,
            owner: opUserId,
            sections: [{
              times: [
                { check_type: 'OnDuty', across: 0, check_time: `1970-01-01 ${startTime}:00`, free_check: false },
                { check_type: 'OffDuty', across: 0, check_time: `1970-01-01 ${endTime}:00`, free_check: false },
              ],
            }],
            setting: { is_flexible: false, serious_late_minutes: -1, absenteeism_late_minutes: -1 },
          });
          shiftByName.set(shiftName, shiftId);
        }
        timeToShiftId.set(key, shiftId);
        shiftCount++;
      } catch (e) {
        this.logger.error(`创建班次 ${shiftName} 失败: ${(e as Error).message}`);
      }
    }

    // ── Step 4: 考勤组列表只查一次，供每个班级匹配 ──
    const existingGroups = await this.dingTalkService.queryAttendanceGroups(opUserId);
    const groupByName = new Map(existingGroups.map((g) => [g.group_name, g.group_id]));

    // ── Step 5: 按班级同步 ──
    const classNameMap = await this.loadClassNames(classIds);
    const schedulesByClass = new Map<number, ClassSchedule[]>();
    for (const s of schedules) {
      const cid = s.classId as number;
      if (!schedulesByClass.has(cid)) schedulesByClass.set(cid, []);
      schedulesByClass.get(cid)!.push(s);
    }

    let syncedItems = 0;
    let skippedNoMapping = 0;
    let groupCount = 0;
    const groupDetails: ScheduleSyncResult['groups'] = [];

    for (const [classId, classSchedules] of schedulesByClass) {
      const className = classNameMap.get(classId) || `班级${classId}`;
      const dingUserIds = classDingUsers.get(classId) ?? [];

      if (dingUserIds.length === 0) {
        this.logger.warn(`班级 ${className} 无钉钉映射学生，跳过 ${classSchedules.length} 条排课`);
        skippedNoMapping += classSchedules.length;
        continue;
      }

      // 该班级用到的班次
      const classShiftIds = new Set<number>();
      for (const s of classSchedules) {
        const sid = timeToShiftId.get(shiftKey(s.startTime, s.endTime));
        if (sid) classShiftIds.add(sid);
      }
      if (classShiftIds.size === 0) {
        this.logger.warn(`班级 ${className} 无可用班次，跳过`);
        skippedNoMapping += classSchedules.length;
        continue;
      }

      // 创建/匹配该班级的考勤组
      const groupName = `排课_${className}`;
      let attendanceGroupId: number;
      try {
        const cached = groupByName.get(groupName);
        if (cached !== undefined) {
          attendanceGroupId = cached;
        } else {
          attendanceGroupId = await this.dingTalkService.createAttendanceGroup({
            name: groupName,
            type: 'TURN',
            owner: opUserId,
            members: dingUserIds.map((uid) => ({ role: 'Attendance', type: 'StaffMember', user_id: uid })),
            shift_ids: [...classShiftIds],
            enable_emp_select_class: true,
            disable_check_without_schedule: false,
            disable_check_when_rest: true,
          });
          groupByName.set(groupName, attendanceGroupId);
        }
        groupCount++;
      } catch (e) {
        this.logger.error(`创建考勤组 ${groupName} 失败: ${(e as Error).message}`);
        skippedNoMapping += classSchedules.length;
        continue;
      }

      // 展开为每个学生的每日排班
      const items = this.expandSchedules(
        classSchedules, dingUserIds, timeToShiftId, startDate, endDate,
      );

      // 批量写入（单次≤200）
      let classItems = 0;
      for (let i = 0; i < items.length; i += 200) {
        const batch = items.slice(i, i + 200);
        try {
          await this.dingTalkService.scheduleUsers(attendanceGroupId, batch, opUserId);
          syncedItems += batch.length;
          classItems += batch.length;
        } catch (e) {
          this.logger.error(`排班写入失败 (groupId=${attendanceGroupId}, offset=${i}): ${(e as Error).message}`);
        }
      }

      groupDetails.push({ className, groupId: attendanceGroupId, itemCount: classItems });
    }

    this.logger.log(
      `排班同步完成: ${schedules.length} 条排课 → ${syncedItems} 条钉钉排班, ` +
      `${shiftCount} 班次, ${groupCount} 考勤组, 跳过 ${skippedNoMapping} 条无映射`,
    );

    return {
      scheduleCount: schedules.length,
      shiftCount,
      groupCount,
      syncedItems,
      skippedNoMapping,
      groups: groupDetails,
    };
  }

  /**
   * 构建 classId → 学生钉钉 userId 列表。
   * 一次性查询所有班级的活跃学生与钉钉映射，避免 N+1。
   */
  private async buildClassDingUserMap(classIds: number[]): Promise<Map<number, string[]>> {
    const result = new Map<number, string[]>();
    if (classIds.length === 0) return result;

    // 班级 → 活跃学生
    const links = await this.classStudentRepo.find({
      where: { classId: In(classIds), status: 'active' },
    });
    if (links.length === 0) return result;

    // 学生 → 钉钉 userId
    const studentIds = [...new Set(links.map((l) => l.studentId))];
    const mappings = await this.mappingRepo.find({
      where: { studentId: In(studentIds) },
    });
    const studentToDing = new Map(mappings.map((m) => [m.studentId, m.dingUserId]));

    for (const link of links) {
      const dingId = studentToDing.get(link.studentId);
      if (!dingId) continue;
      if (!result.has(link.classId)) result.set(link.classId, []);
      const arr = result.get(link.classId)!;
      if (!arr.includes(dingId)) arr.push(dingId);
    }
    return result;
  }

  private async loadClassNames(classIds: number[]): Promise<Map<number, string>> {
    const map = new Map<number, string>();
    if (classIds.length === 0) return map;
    const classes = await this.classRepo.find({ where: { id: In(classIds) } });
    for (const c of classes) map.set(c.id, c.name);
    return map;
  }

  /**
   * 将排课记录展开为每个学生的每日排班数组。
   * 每条 ClassSchedule(weekDay, startDate-endDate) × 班级每个学生 →
   * 该日期范围内所有 weekDay 对应日期的排班。
   */
  private expandSchedules(
    schedules: ClassSchedule[],
    dingUserIds: string[],
    timeToShiftId: Map<string, number>,
    syncFrom: string,
    syncTo: string,
  ): DingTalkScheduleItem[] {
    const items: DingTalkScheduleItem[] = [];
    const fromDate = new Date(syncFrom);
    const toDate = new Date(syncTo);

    // 预计算日期范围内每一天是星期几（周日=7）
    const dateWeekDays = new Map<string, number>();
    for (let d = new Date(fromDate); d <= toDate; d.setDate(d.getDate() + 1)) {
      const dateStr = d.toISOString().slice(0, 10);
      dateWeekDays.set(dateStr, d.getDay() === 0 ? 7 : d.getDay());
    }

    for (const s of schedules) {
      const shiftId = timeToShiftId.get(`${s.startTime}-${s.endTime}`);
      if (!shiftId) continue;

      const scheduleStart = s.startDate > syncFrom ? s.startDate : syncFrom;
      const scheduleEnd = s.endDate < syncTo ? s.endDate : syncTo;

      for (const [dateStr, weekDay] of dateWeekDays) {
        if (dateStr < scheduleStart || dateStr > scheduleEnd) continue;
        if (weekDay !== s.weekDay) continue;

        const workDate = new Date(dateStr + 'T00:00:00+08:00').getTime();
        for (const userid of dingUserIds) {
          items.push({ userid, work_date: workDate, shift_id: shiftId, is_rest: false });
        }
      }
    }

    return items;
  }

  private addDays(dateStr: string, days: number): string {
    const d = new Date(dateStr);
    d.setDate(d.getDate() + days);
    return d.toISOString().slice(0, 10);
  }

  /** 获取排班同步状态：活跃排课数、有钉钉映射学生的班级数 */
  async getStatus(_targetDate: string): Promise<{
    activeSchedules: number;
    mappedClasses: number;
    totalClasses: number;
  }> {
    const allSchedules = await this.scheduleRepo.find({ where: { status: 'active' } });
    const schedules = allSchedules.filter((s) => s.classId != null);
    const classIds = [...new Set(schedules.map((s) => s.classId as number))];
    const classDingUsers = await this.buildClassDingUserMap(classIds);
    const mappedClasses = [...classDingUsers.values()].filter((u) => u.length > 0).length;

    return {
      activeSchedules: schedules.length,
      mappedClasses,
      totalClasses: classIds.length,
    };
  }
}