import { saveLayout } from '../class-plans/class-plans.service.js';
import { prisma } from '../../lib/db.js';
import { ApiError } from '../../lib/http.js';
import type { TokenPayload } from '../../lib/jwt.js';
import { logger } from '../../lib/logger.js';
import { assertCanManageSchedule } from '../../lib/access.js';
import type { TimeLayoutImportInput } from './imports.schemas.js';

/**
 * ClassIsland 课表时间（TimeLayout）导入。
 *
 * ClassIsland 的导出结构在不同版本里略有差异，常见形态：
 *   1. 顶层就是数组：`[{ StartTime: "8:0:0", EndTime: "8:45:0", TimeType: 0 }, ...]`
 *   2. 包在对象里：`{ TimeLayouts: [...] }` / `{ TimeLayoutItems: [...] }` / `{ items: [...] }`
 *   3. 时间用秒表示：`{ StartSecond: 28800, EndSecond: 31500 }`
 *   4. 字段名大小写/命名不同：`StartTime` / `startTime` / `Start`；`Name` / `Title`
 *
 * 因此这里做**容错解析**：先把可能的数组抠出来，再逐条按候选字段名解析时间，
 * 解析失败的行进入 errors（不写库），成功解析但可疑的进入 warnings（可继续导入）。
 */
export type TimeLayoutItemType = 'class' | 'break' | 'divider' | 'action';

export interface ParsedTimeLayoutItem {
  index: number;
  name: string;
  startTime: string;
  endTime: string;
  type: TimeLayoutItemType;
  skipped: boolean;
}

export interface TimeLayoutParseResult {
  items: ParsedTimeLayoutItem[];
  errors: string[];
  warnings: string[];
}

const TIME_KEYS = ['StartTime', 'startTime', 'start', 'Start'] as const;
const END_KEYS = ['EndTime', 'endTime', 'end', 'End'] as const;
const START_SECOND_KEYS = ['StartSecond', 'startSecond', 'StartSeconds'] as const;
const END_SECOND_KEYS = ['EndSecond', 'endSecond', 'EndSeconds'] as const;
const NAME_KEYS = ['Name', 'name', 'Title', 'title', 'Subject'] as const;
const TYPE_KEYS = ['TimeType', 'timeType', 'Type', 'type'] as const;
const SKIP_KEYS = ['IsSkipped', 'isSkipped', 'Skipped', 'skip'] as const;

function pick(record: Record<string, unknown>, keys: readonly string[]): unknown {
  for (const key of keys) {
    if (record[key] !== undefined && record[key] !== null) return record[key];
  }
  return undefined;
}

/** 把 ClassIsland 的时间写法统一成 HH:mm */
function normalizeTime(value: unknown): string | null {
  if (typeof value === 'number' && Number.isFinite(value)) {
    // 数字：优先按"秒"解释（ClassIsland 的 StartSecond），小于 100 时按"分钟"
    const seconds = value > 100 ? value : value * 60;
    return secondsToHHmm(seconds);
  }
  if (typeof value !== 'string') return null;
  const text = value.trim();
  if (!text) return null;

  // HH:mm / H:mm / HH:mm:ss / H:mm:ss
  const match = /^(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/.exec(text);
  if (match) {
    const hour = Number(match[1]);
    const minute = Number(match[2]);
    if (hour > 23 || minute > 59) return null;
    return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
  }

  // ISO 字符串（ClassIsland 某些版本导出 "2024-01-01T08:00:00"）
  const parsed = new Date(text);
  if (!Number.isNaN(parsed.getTime())) {
    return `${String(parsed.getHours()).padStart(2, '0')}:${String(parsed.getMinutes()).padStart(2, '0')}`;
  }
  return null;
}

function secondsToHHmm(seconds: number): string {
  const total = Math.max(0, Math.round(seconds));
  const hour = Math.floor(total / 3600) % 24;
  const minute = Math.floor((total % 3600) / 60);
  return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
}

/**
 * 从任意形态里抠出"可能是时间表条目"的数组。
 *
 * ClassIsland 真实档案（`Profiles/<档案名>.json`，1.7.106+ / 2.x）里是：
 *   `{ "TimeLayouts": { "<guid>": { "Name": "默认", "Layouts": [ { StartTime, EndTime, TimeType } ] } } }`
 * —— 即**按 Guid 索引的字典**，条目在各自的 `Layouts` 里。早期版本还可能直接是数组或 `{ items: [...] }`。
 * 之前只认数组 / `.items`，导致真实导出文件完全导不进来（本次修复）。
 */
function extractItems(input: unknown): { items: unknown[]; shape: string } {
  if (Array.isArray(input)) return { items: input, shape: 'array' };
  if (input && typeof input === 'object') {
    const record = input as Record<string, unknown>;
    for (const key of ['TimeLayouts', 'TimeLayoutItems', 'Items', 'items', 'Layouts']) {
      const value = record[key];
      if (Array.isArray(value)) return { items: value, shape: key };
      // 有些导出是 { TimeLayouts: { items: [...] } }
      const nestedItems =
        value && typeof value === 'object' ? (value as Record<string, unknown>).items : null;
      if (Array.isArray(nestedItems)) {
        return { items: nestedItems as unknown[], shape: `${key}.items` };
      }
      // ClassIsland 真实形态：Guid → { Name, Layouts: [...] }；合并所有时间表的 Layouts
      if (value && typeof value === 'object' && !Array.isArray(value)) {
        const merged: unknown[] = [];
        let layoutCount = 0;
        for (const entry of Object.values(value as Record<string, unknown>)) {
          const layoutRecord = entry && typeof entry === 'object' ? (entry as Record<string, unknown>) : null;
          const layouts = layoutRecord?.Layouts ?? layoutRecord?.layouts;
          if (Array.isArray(layouts)) {
            merged.push(...layouts);
            layoutCount += 1;
          }
        }
        if (merged.length > 0) {
          return { items: merged, shape: `${key}{guid}×${layoutCount}` };
        }
      }
    }
    // 单个时间表对象：{ Name, Layouts: [...] }
    const single = record.Layouts ?? record.layouts;
    if (Array.isArray(single)) return { items: single, shape: 'Layouts' };
  }
  return { items: [], shape: 'unknown' };
}

function normalizeType(record: Record<string, unknown>): TimeLayoutItemType {
  const raw = pick(record, TYPE_KEYS);
  const numeric = typeof raw === 'number' ? raw : typeof raw === 'string' ? Number(raw) : Number.NaN;
  if (numeric === 1) return 'break';
  if (numeric === 3) return 'action'; // ClassIsland TimeType=3：行动（非上课/课间）
  if (numeric === 2) return 'divider';
  return 'class';
}

export function parseClassIslandTimeLayout(input: unknown): TimeLayoutParseResult {
  let payload = input;
  if (typeof payload === 'string') {
    try {
      payload = JSON.parse(payload);
    } catch (error) {
      return { items: [], errors: [`JSON 解析失败：${(error as Error).message}`], warnings: [] };
    }
  }

  const { items: rawItems, shape } = extractItems(payload);
  const errors: string[] = [];
  const warnings: string[] = [];

  if (rawItems.length === 0) {
    return {
      items: [],
      errors: [
        '未识别到时间表条目：请确认是 ClassIsland 导出的课表时间 JSON（数组或含 TimeLayouts/TimeLayoutItems 字段）',
      ],
      warnings: [],
    };
  }
  if (shape === 'unknown') {
    warnings.push('未识别外层结构，已尝试按数组解析');
  }

  const parsed: ParsedTimeLayoutItem[] = [];
  rawItems.forEach((raw, index) => {
    if (!raw || typeof raw !== 'object') {
      errors.push(`第 ${index + 1} 条：不是对象，已跳过`);
      return;
    }
    const record = raw as Record<string, unknown>;

    const start =
      normalizeTime(pick(record, TIME_KEYS)) ?? normalizeTime(pick(record, START_SECOND_KEYS)) ?? null;
    const end = normalizeTime(pick(record, END_KEYS)) ?? normalizeTime(pick(record, END_SECOND_KEYS)) ?? null;

    const skipped = pick(record, SKIP_KEYS) === true || pick(record, SKIP_KEYS) === 'true';
    const type = normalizeType(record);
    const nameRaw = pick(record, NAME_KEYS);
    const name = typeof nameRaw === 'string' && nameRaw.trim() ? nameRaw.trim() : '';

    if (!start || !end) {
      if (type === 'divider') {
        warnings.push(`第 ${index + 1} 条：分割线没有时间，已忽略`);
        return;
      }
      errors.push(
        `第 ${index + 1} 条（${name || '未命名'}）：无法解析开始/结束时间` +
          `（支持 StartTime: "8:0:0"、StartSecond: 28800 等写法）`,
      );
      return;
    }
    if (start >= end) {
      errors.push(`第 ${index + 1} 条（${name || '未命名'}）：结束时间 ${end} 不晚于开始时间 ${start}`);
      return;
    }
    if (skipped) warnings.push(`第 ${index + 1} 条（${name || '未命名'}）：原配置标记为跳过`);

    parsed.push({
      index: parsed.length + 1,
      name: name || `第 ${parsed.length + 1} 节`,
      startTime: start,
      endTime: end,
      type,
      skipped,
    });
  });

  // 排序 + 重叠检测（不阻断导入，仅提示）
  parsed.sort((a, b) => a.startTime.localeCompare(b.startTime));
  for (let index = 1; index < parsed.length; index += 1) {
    const previous = parsed[index - 1];
    const current = parsed[index];
    if (
      previous &&
      current &&
      previous.type === 'class' &&
      current.type === 'class' &&
      current.startTime < previous.endTime
    ) {
      warnings.push(
        `时间重叠：${previous.startTime}-${previous.endTime} 与 ${current.startTime}-${current.endTime}`,
      );
    }
  }

  return { items: parsed, errors, warnings };
}

export interface TimeLayoutDto {
  id: string;
  classId: string | null;
  name: string;
  source: string;
  items: ParsedTimeLayoutItem[];
  createdAt: string;
  updatedAt: string;
}

function toDto(record: {
  id: string;
  classId: string | null;
  name: string;
  source: string;
  items: string;
  points?: Array<{
    position: number;
    name: string;
    startTime: string;
    endTime: string;
    timeType: string;
    isHideDefault: boolean;
  }>;
  createdAt: Date;
  updatedAt: Date;
}): TimeLayoutDto {
  let items: ParsedTimeLayoutItem[] = [];
  try {
    items = JSON.parse(record.items) as ParsedTimeLayoutItem[];
  } catch {
    items = [];
  }
  if (record.points?.length)
    items = record.points.map((p) => ({
      index: p.position,
      name: p.name,
      startTime: p.startTime,
      endTime: p.endTime,
      type: (p.timeType === 'LESSON'
        ? 'class'
        : p.timeType === 'BREAK'
          ? 'break'
          : p.timeType === 'DIVIDER'
            ? 'divider'
            : 'action') as ParsedTimeLayoutItem['type'],
      skipped: p.isHideDefault,
    }));
  return {
    id: record.id,
    classId: record.classId,
    name: record.name,
    source: record.source,
    items,
    createdAt: record.createdAt.toISOString(),
    updatedAt: record.updatedAt.toISOString(),
  };
}

/** 预览：只解析不落库（失败时原配置不受影响） */
export function previewClassIslandTimeLayout(payload: unknown): TimeLayoutParseResult & { shape: string } {
  return {
    ...parseClassIslandTimeLayout(payload),
    shape: extractItems(typeof payload === 'string' ? safeJson(payload) : payload).shape,
  };
}

function safeJson(text: string): unknown {
  try {
    return JSON.parse(text);
  } catch {
    return text;
  }
}

export async function listTimeLayouts(user: TokenPayload, classId: string): Promise<TimeLayoutDto[]> {
  await assertCanManageSchedule(user, classId);
  const records = await prisma.timeLayout.findMany({
    where: { classId },
    include: { points: { orderBy: { position: 'asc' } } },
    orderBy: { updatedAt: 'desc' },
  });
  return records.map(toDto);
}

/**
 * 导入（写入）：解析 → 有错误直接 400（不写库）→ 按 replace/merge 落库。
 * 写入路由要求 timetable:manage，班级范围仍由本服务校验。
 */
export async function importTimeLayout(
  user: TokenPayload,
  input: TimeLayoutImportInput,
): Promise<{ layout: TimeLayoutDto; mode: string; warnings: string[]; replaced: number; merged: number }> {
  await assertCanManageSchedule(user, input.classId);

  const parsed = parseClassIslandTimeLayout(input.payload);
  if (parsed.errors.length > 0) {
    throw new ApiError(400, 'IMPORT_INVALID', '课表时间配置解析失败，已保持原有配置不变', {
      errors: parsed.errors,
      warnings: parsed.warnings,
    });
  }
  if (parsed.items.length === 0) {
    throw new ApiError(400, 'IMPORT_EMPTY', '没有解析到任何有效节次，已保持原有配置不变', {
      warnings: parsed.warnings,
    });
  }

  const name = input.name?.trim() || '默认时间表';
  const current = await prisma.timeLayout.findFirst({
    where: { classId: input.classId, name },
    include: { points: { orderBy: { position: 'asc' } } },
  });
  const previous = current ? toDto(current).items : [];
  const starts = new Set(parsed.items.map((p) => p.startTime));
  const merged =
    input.mode === 'merge'
      ? parsed.items.filter((p) => previous.some((old) => old.startTime === p.startTime)).length
      : 0;
  const combined =
    input.mode === 'merge'
      ? [...previous.filter((p) => !starts.has(p.startTime)), ...parsed.items].sort((a, b) =>
          a.startTime.localeCompare(b.startTime),
        )
      : parsed.items;
  const claimed = new Set<string>();
  const points = combined.map((p, position) => {
    const timeType = ({ class: 'LESSON', break: 'BREAK', divider: 'DIVIDER', action: 'ACTION' } as const)[
      p.type
    ];
    const candidates =
      current?.points.filter(
        (old) => !claimed.has(old.id) && old.startTime === p.startTime && old.timeType === timeType,
      ) || [];
    const previousPoint = candidates.find((old) => old.endTime === p.endTime) || candidates[0];
    if (previousPoint) claimed.add(previousPoint.id);
    return {
      id: previousPoint?.id,
      position,
      name: p.name,
      startTime: p.startTime,
      endTime: p.endTime,
      timeType,
      isHideDefault: p.skipped,
      defaultClassId: null,
      breakName: p.type === 'break' ? p.name : '',
      actionSet: '{}',
    };
  });
  const layout = await saveLayout({ classId: input.classId, name, points }, current?.id);
  logger.info(`课表时间配置导入：班级=${input.classId} 模式=${input.mode} 共 ${combined.length} 个时间点`);
  return {
    layout: toDto(layout),
    mode: input.mode,
    warnings: parsed.warnings,
    replaced: parsed.items.length - merged,
    merged,
  };
}

export async function deleteTimeLayout(user: TokenPayload, layoutId: string): Promise<void> {
  const record = await prisma.timeLayout.findUnique({ where: { id: layoutId } });
  if (!record) throw ApiError.notFound('时间配置不存在');
  if (!record.classId) throw ApiError.forbidden('全校时间表请在时间表编辑器管理');
  await assertCanManageSchedule(user, record.classId);
  if (await prisma.classPlan.count({ where: { timeLayoutId: layoutId } }))
    throw ApiError.conflict('仍有课表使用该时间表');
  await prisma.timeLayout.delete({ where: { id: layoutId } });
}