import { createOpaqueId } from "../core/ids";
import {
  areControlEffectsEqual,
  cloneControlEffect,
  cloneControlTargetRef,
  getControlEffectResolutionKey,
  type ControlEffect,
  type ControlTargetRef,
  createActorControlTargetRef,
  createSetActorPresenceControlEffect,
  getControlTargetRefKey
} from "../controls/control-surface";
import {
  HOURS_PER_DAY,
  normalizeTimeOfDayHours
} from "../document/project-time-settings";

export const PROJECT_SCHEDULE_WEEKDAYS = [
  "monday",
  "tuesday",
  "wednesday",
  "thursday",
  "friday",
  "saturday",
  "sunday"
] as const;

export type ProjectScheduleWeekday =
  (typeof PROJECT_SCHEDULE_WEEKDAYS)[number];

export interface ProjectScheduleEveryDaySelection {
  mode: "everyDay";
}

export interface ProjectScheduleSelectedDaysSelection {
  mode: "selectedDays";
  days: ProjectScheduleWeekday[];
}

export type ProjectScheduleDaySelection =
  | ProjectScheduleEveryDaySelection
  | ProjectScheduleSelectedDaysSelection;

export interface ProjectScheduleRoutine {
  id: string;
  title: string;
  enabled: boolean;
  target: ControlTargetRef;
  sequenceId: string | null;
  days: ProjectScheduleDaySelection;
  startHour: number;
  endHour: number;
  priority: number;
  effects: ControlEffect[];
}

export interface ProjectScheduler {
  routines: Record<string, ProjectScheduleRoutine>;
}

export interface ProjectScheduleTimelineSegment {
  key: string;
  startHour: number;
  endHour: number;
}

export const DEFAULT_PROJECT_SCHEDULE_START_HOUR = 9 as const;
export const DEFAULT_PROJECT_SCHEDULE_END_HOUR = 17 as const;

function assertNonEmptyString(value: string, label: string) {
  if (value.trim().length === 0) {
    throw new Error(`${label} must be non-empty.`);
  }
}

function assertFiniteNumber(value: number, label: string) {
  if (!Number.isFinite(value)) {
    throw new Error(`${label} must be a finite number.`);
  }
}

function normalizeProjectSchedulePriority(priority: number | undefined): number {
  if (priority === undefined || !Number.isFinite(priority)) {
    return 0;
  }

  return Math.trunc(priority);
}

function normalizeProjectScheduleDays(
  days: ProjectScheduleDaySelection | undefined
): ProjectScheduleDaySelection {
  if (days === undefined || days.mode === "everyDay") {
    return createProjectScheduleEveryDaySelection();
  }

  const deduplicatedDays = [...new Set(days.days)].filter(isProjectScheduleWeekday);

  if (deduplicatedDays.length === 0) {
    throw new Error("Project schedule selected days must include at least one day.");
  }

  if (deduplicatedDays.length === PROJECT_SCHEDULE_WEEKDAYS.length) {
    return createProjectScheduleEveryDaySelection();
  }

  return {
    mode: "selectedDays",
    days: deduplicatedDays
  };
}

function normalizeProjectScheduleTitle(title: string | undefined): string {
  const normalizedTitle = title?.trim() ?? "";

  if (normalizedTitle.length === 0) {
    throw new Error("Project schedule routine title must be non-empty.");
  }

  return normalizedTitle;
}

function normalizeProjectScheduleSequenceId(
  sequenceId: string | null | undefined
): string | null {
  if (sequenceId === undefined || sequenceId === null) {
    return null;
  }

  const normalizedSequenceId = sequenceId.trim();

  if (normalizedSequenceId.length === 0) {
    throw new Error("Project schedule routine sequence ids must be non-empty.");
  }

  return normalizedSequenceId;
}

function normalizeProjectScheduleHours(value: number, label: string): number {
  assertFiniteNumber(value, label);
  return normalizeTimeOfDayHours(value);
}

function compareProjectScheduleEffectOrder(
  left: ControlEffect,
  right: ControlEffect
): number {
  const getOrder = (effect: ControlEffect): number => {
    switch (effect.type) {
      case "setActorPresence":
        return 0;
      case "playActorAnimation":
        return 1;
      case "followActorPath":
        return 2;
      default:
        return 10;
    }
  };

  return (
    getOrder(left) - getOrder(right) ||
    getControlEffectResolutionKey(left).localeCompare(
      getControlEffectResolutionKey(right)
    )
  );
}

function normalizeProjectScheduleEffects(
  target: ControlTargetRef,
  sequenceId: string | null,
  options: {
    effect?: ControlEffect;
    effects?: ControlEffect[];
  }
): ControlEffect[] {
  const authoredEffects =
    options.effects !== undefined
      ? options.effects
      : options.effect === undefined
        ? []
        : [options.effect];
  const normalizedEffects = authoredEffects.map(cloneControlEffect);

  if (normalizedEffects.length === 0 && target.kind === "global") {
    return [];
  }

  if (normalizedEffects.length === 0 && sequenceId !== null) {
    return [];
  }

  if (normalizedEffects.length === 0 && target.kind !== "actor") {
    throw new Error(
      "Project schedule routines must author an explicit control effect for non-actor targets."
    );
  }

  for (const effect of normalizedEffects) {
    if (getControlTargetRefKey(effect.target) !== getControlTargetRefKey(target)) {
      throw new Error(
        "Project schedule routine effects must target the same authored control target."
      );
    }
  }

  if (
    target.kind === "actor" &&
    !normalizedEffects.some((effect) => effect.type === "setActorPresence")
  ) {
    normalizedEffects.push(
      createSetActorPresenceControlEffect({
        target,
        active: true
      })
    );
  }

  if (normalizedEffects.length === 0) {
    throw new Error("Project schedule routines must contain at least one control effect.");
  }

  if (target.kind !== "actor" && normalizedEffects.length !== 1) {
    throw new Error(
      "Non-actor project schedule routines must currently author exactly one control effect."
    );
  }

  const seenResolutionKeys = new Set<string>();

  for (const effect of normalizedEffects) {
    const resolutionKey = getControlEffectResolutionKey(effect);

    if (seenResolutionKeys.has(resolutionKey)) {
      throw new Error(
        `Project schedule routines cannot author multiple effects for ${resolutionKey}.`
      );
    }

    seenResolutionKeys.add(resolutionKey);
  }

  normalizedEffects.sort(compareProjectScheduleEffectOrder);
  return normalizedEffects;
}

export function isProjectScheduleWeekday(
  value: unknown
): value is ProjectScheduleWeekday {
  return PROJECT_SCHEDULE_WEEKDAYS.includes(value as ProjectScheduleWeekday);
}

export function createProjectScheduleEveryDaySelection(): ProjectScheduleEveryDaySelection {
  return {
    mode: "everyDay"
  };
}

export function createProjectScheduleSelectedDaysSelection(
  days: ProjectScheduleWeekday[]
): ProjectScheduleSelectedDaysSelection {
  return normalizeProjectScheduleDays({
    mode: "selectedDays",
    days
  }) as ProjectScheduleSelectedDaysSelection;
}

export function createEmptyProjectScheduler(): ProjectScheduler {
  return {
    routines: {}
  };
}

export function createProjectScheduleRoutine(
  overrides: Partial<
    Pick<
      ProjectScheduleRoutine,
      | "id"
      | "title"
      | "enabled"
      | "target"
      | "sequenceId"
      | "days"
      | "startHour"
      | "endHour"
      | "priority"
      | "effects"
    >
  > & {
    effect?: ControlEffect;
  } &
    Pick<ProjectScheduleRoutine, "target" | "title"> = {
    target: createActorControlTargetRef("actor-default"),
    title: "Routine"
  }
): ProjectScheduleRoutine {
  const target = cloneControlTargetRef(overrides.target);
  const sequenceId = normalizeProjectScheduleSequenceId(overrides.sequenceId);
  const startHour = normalizeProjectScheduleHours(
    overrides.startHour ?? DEFAULT_PROJECT_SCHEDULE_START_HOUR,
    "Project schedule start hour"
  );
  const endHour = normalizeProjectScheduleHours(
    overrides.endHour ?? DEFAULT_PROJECT_SCHEDULE_END_HOUR,
    "Project schedule end hour"
  );

  if (startHour === endHour) {
    throw new Error("Project schedule routines must span at least part of the day.");
  }

  return {
    id: overrides.id ?? createOpaqueId("schedule-routine"),
    title: normalizeProjectScheduleTitle(overrides.title),
    enabled: overrides.enabled ?? true,
    target,
    sequenceId,
    days: normalizeProjectScheduleDays(overrides.days),
    startHour,
    endHour,
    priority: normalizeProjectSchedulePriority(overrides.priority),
    effects: normalizeProjectScheduleEffects(target, sequenceId, {
      effect: overrides.effect,
      effects: overrides.effects
    })
  };
}

export function cloneProjectScheduleDaySelection(
  days: ProjectScheduleDaySelection
): ProjectScheduleDaySelection {
  switch (days.mode) {
    case "everyDay":
      return createProjectScheduleEveryDaySelection();
    case "selectedDays":
      return createProjectScheduleSelectedDaysSelection(days.days);
  }
}

export function cloneProjectScheduleRoutine(
  routine: ProjectScheduleRoutine
): ProjectScheduleRoutine {
  return {
    id: routine.id,
    title: routine.title,
    enabled: routine.enabled,
    target: cloneControlTargetRef(routine.target),
    sequenceId: routine.sequenceId,
    days: cloneProjectScheduleDaySelection(routine.days),
    startHour: routine.startHour,
    endHour: routine.endHour,
    priority: routine.priority,
    effects: routine.effects.map(cloneControlEffect)
  };
}

export function cloneProjectScheduler(
  scheduler: ProjectScheduler
): ProjectScheduler {
  return {
    routines: Object.fromEntries(
      Object.entries(scheduler.routines).map(([routineId, routine]) => [
        routineId,
        cloneProjectScheduleRoutine(routine)
      ])
    )
  };
}

export function areProjectScheduleDaySelectionsEqual(
  left: ProjectScheduleDaySelection,
  right: ProjectScheduleDaySelection
): boolean {
  if (left.mode !== right.mode) {
    return false;
  }

  if (left.mode === "everyDay") {
    return true;
  }

  return (
    right.mode === "selectedDays" &&
    left.days.length === right.days.length &&
    left.days.every((day, index) => day === right.days[index])
  );
}

export function areProjectScheduleRoutinesEqual(
  left: ProjectScheduleRoutine,
  right: ProjectScheduleRoutine
): boolean {
  return (
    left.id === right.id &&
    left.title === right.title &&
    left.enabled === right.enabled &&
    getControlTargetRefKey(left.target) === getControlTargetRefKey(right.target) &&
    left.sequenceId === right.sequenceId &&
    areProjectScheduleDaySelectionsEqual(left.days, right.days) &&
    left.startHour === right.startHour &&
    left.endHour === right.endHour &&
    left.priority === right.priority &&
    left.effects.length === right.effects.length &&
    left.effects.every((effect, index) =>
      areControlEffectsEqual(effect, right.effects[index] as ControlEffect)
    )
  );
}

export function findProjectScheduleRoutineEffect<
  TType extends ControlEffect["type"]
>(
  routine: ProjectScheduleRoutine,
  type: TType
): Extract<ControlEffect, { type: TType }> | null {
  return (
    routine.effects.find(
      (effect): effect is Extract<ControlEffect, { type: TType }> =>
        effect.type === type
    ) ?? null
  );
}

export function areProjectSchedulersEqual(
  left: ProjectScheduler,
  right: ProjectScheduler
): boolean {
  const leftRoutineIds = Object.keys(left.routines);
  const rightRoutineIds = Object.keys(right.routines);

  if (leftRoutineIds.length !== rightRoutineIds.length) {
    return false;
  }

  return leftRoutineIds.every((routineId) => {
    const leftRoutine = left.routines[routineId];
    const rightRoutine = right.routines[routineId];

    return (
      leftRoutine !== undefined &&
      rightRoutine !== undefined &&
      areProjectScheduleRoutinesEqual(leftRoutine, rightRoutine)
    );
  });
}

export function resolveProjectScheduleWeekday(
  dayNumber: number
): ProjectScheduleWeekday {
  const normalizedDayNumber = Math.floor(Number.isFinite(dayNumber) ? dayNumber : 1);
  const zeroBasedDayIndex =
    ((normalizedDayNumber - 1) % PROJECT_SCHEDULE_WEEKDAYS.length +
      PROJECT_SCHEDULE_WEEKDAYS.length) %
    PROJECT_SCHEDULE_WEEKDAYS.length;

  return PROJECT_SCHEDULE_WEEKDAYS[zeroBasedDayIndex] ?? "monday";
}

export function getPreviousProjectScheduleWeekday(
  weekday: ProjectScheduleWeekday
): ProjectScheduleWeekday {
  const dayIndex = PROJECT_SCHEDULE_WEEKDAYS.indexOf(weekday);
  return (
    PROJECT_SCHEDULE_WEEKDAYS[
      (dayIndex - 1 + PROJECT_SCHEDULE_WEEKDAYS.length) %
        PROJECT_SCHEDULE_WEEKDAYS.length
    ] ?? "sunday"
  );
}

export function isProjectScheduleDaySelectionActive(
  days: ProjectScheduleDaySelection,
  weekday: ProjectScheduleWeekday
): boolean {
  switch (days.mode) {
    case "everyDay":
      return true;
    case "selectedDays":
      return days.days.includes(weekday);
  }
}

export function isProjectScheduleRoutineActiveAt(
  routine: ProjectScheduleRoutine,
  dayNumber: number,
  timeOfDayHours: number
): boolean {
  if (!routine.enabled) {
    return false;
  }

  const normalizedTimeOfDayHours = normalizeTimeOfDayHours(timeOfDayHours);
  const weekday = resolveProjectScheduleWeekday(dayNumber);

  if (routine.startHour < routine.endHour) {
    return (
      isProjectScheduleDaySelectionActive(routine.days, weekday) &&
      normalizedTimeOfDayHours >= routine.startHour &&
      normalizedTimeOfDayHours < routine.endHour
    );
  }

  return (
    (isProjectScheduleDaySelectionActive(routine.days, weekday) &&
      normalizedTimeOfDayHours >= routine.startHour) ||
    (isProjectScheduleDaySelectionActive(
      routine.days,
      getPreviousProjectScheduleWeekday(weekday)
    ) &&
      normalizedTimeOfDayHours < routine.endHour)
  );
}

export function getProjectScheduleRoutineDurationHours(
  routine: Pick<ProjectScheduleRoutine, "startHour" | "endHour">
): number {
  return routine.startHour < routine.endHour
    ? routine.endHour - routine.startHour
    : HOURS_PER_DAY - routine.startHour + routine.endHour;
}

export function getProjectScheduleRoutineElapsedHoursAt(
  routine: ProjectScheduleRoutine,
  dayNumber: number,
  timeOfDayHours: number
): number | null {
  if (!isProjectScheduleRoutineActiveAt(routine, dayNumber, timeOfDayHours)) {
    return null;
  }

  const normalizedTimeOfDayHours = normalizeTimeOfDayHours(timeOfDayHours);
  const weekday = resolveProjectScheduleWeekday(dayNumber);

  if (routine.startHour < routine.endHour) {
    return normalizedTimeOfDayHours - routine.startHour;
  }

  if (
    isProjectScheduleDaySelectionActive(routine.days, weekday) &&
    normalizedTimeOfDayHours >= routine.startHour
  ) {
    return normalizedTimeOfDayHours - routine.startHour;
  }

  return HOURS_PER_DAY - routine.startHour + normalizedTimeOfDayHours;
}

export function compareProjectScheduleRoutinePriority(
  left: ProjectScheduleRoutine,
  right: ProjectScheduleRoutine
): number {
  return (
    right.priority - left.priority ||
    left.startHour - right.startHour ||
    left.title.localeCompare(right.title) ||
    left.id.localeCompare(right.id)
  );
}

export function getProjectScheduleTimelineSegments(
  routine: Pick<ProjectScheduleRoutine, "id" | "startHour" | "endHour">
): ProjectScheduleTimelineSegment[] {
  if (routine.startHour < routine.endHour) {
    return [
      {
        key: `${routine.id}:primary`,
        startHour: routine.startHour,
        endHour: routine.endHour
      }
    ];
  }

  return [
    {
      key: `${routine.id}:late`,
      startHour: routine.startHour,
      endHour: HOURS_PER_DAY
    },
    {
      key: `${routine.id}:early`,
      startHour: 0,
      endHour: routine.endHour
    }
  ];
}

export function formatProjectScheduleWeekdayLabel(
  weekday: ProjectScheduleWeekday
): string {
  switch (weekday) {
    case "monday":
      return "Mon";
    case "tuesday":
      return "Tue";
    case "wednesday":
      return "Wed";
    case "thursday":
      return "Thu";
    case "friday":
      return "Fri";
    case "saturday":
      return "Sat";
    case "sunday":
      return "Sun";
  }
}

export function formatProjectScheduleDaySelection(
  days: ProjectScheduleDaySelection
): string {
  switch (days.mode) {
    case "everyDay":
      return "Every day";
    case "selectedDays":
      return days.days.map(formatProjectScheduleWeekdayLabel).join(", ");
  }
}

export function upsertProjectScheduleRoutine(
  scheduler: ProjectScheduler,
  routine: ProjectScheduleRoutine
): ProjectScheduler {
  assertNonEmptyString(routine.id, "Project schedule routine id");

  return {
    routines: {
      ...scheduler.routines,
      [routine.id]: cloneProjectScheduleRoutine(routine)
    }
  };
}

export function removeProjectScheduleRoutine(
  scheduler: ProjectScheduler,
  routineId: string
): ProjectScheduler {
  if (scheduler.routines[routineId] === undefined) {
    return cloneProjectScheduler(scheduler);
  }

  const nextRoutines = { ...scheduler.routines };
  delete nextRoutines[routineId];

  return {
    routines: nextRoutines
  };
}