003: 만우절 장난 미리 세팅해두기

const APRIL_FOOLS_CONFIG = Object.freeze({
  enabled: true,
  timeZone: "Asia/Seoul",
  month: 4,
  day: 1,
  serverTimeProbeUrl: "/static/brand-config.js",
  serverTimeTimeoutMs: 3500,
  brandUiWaitMs: 4000,
  fallbackToClientTime: true,
  headlineText: "교육행정 업무 비효율화 웹페이지",
  headlineHtml:
    '교육행정 업무 <span class="april-fools-highlight">비효율화</span> 웹페이지',
  highlightColor: "#c62828"
});

function addCacheBuster(url) {
  const target = new URL(url, window.location.href);
  target.searchParams.set("__server_time", String(Date.now()));
  return target.toString();
}

async function requestServerDate(method) {
  const controller = new AbortController();
  const timeoutId = window.setTimeout(() => {
    controller.abort();
  }, APRIL_FOOLS_CONFIG.serverTimeTimeoutMs);

  try {
    const response = await fetch(
      addCacheBuster(APRIL_FOOLS_CONFIG.serverTimeProbeUrl),
      {
        method,
        cache: "no-store",
        credentials: "same-origin",
        signal: controller.signal
      }
    );

    if (!response.ok) {
      throw new Error("서버 시간 확인 응답 오류: HTTP " + response.status);
    }

    const rawDate = response.headers.get("Date");
    const timestamp = rawDate ? Date.parse(rawDate) : NaN;

    if (!Number.isFinite(timestamp)) {
      throw new Error("서버 응답에 유효한 Date 헤더가 없습니다.");
    }

    if (method === "GET" && response.body) {
      try {
        await response.body.cancel();
      } catch (_) {}
    }

    return timestamp;
  } finally {
    window.clearTimeout(timeoutId);
  }
}

async function getServerTimestamp() {
  try {
    return await requestServerDate("HEAD");
  } catch (headError) {
    try {
      return await requestServerDate("GET");
    } catch (getError) {
      const error = new Error("서버 시간을 확인하지 못했습니다.");
      error.cause = getError || headError;
      throw error;
    }
  }
}

async function waitForBrandUi() {
  const startedAt = performance.now();

  while (
    !window.BrandUI &&
    performance.now() - startedAt < APRIL_FOOLS_CONFIG.brandUiWaitMs
  ) {
    await wait(50);
  }
}

function setAprilFoolsHeadline(heroTitle) {
  if (!heroTitle) return;

  if (heroTitle.innerHTML !== APRIL_FOOLS_CONFIG.headlineHtml) {
    heroTitle.innerHTML = APRIL_FOOLS_CONFIG.headlineHtml;
  }

  heroTitle.setAttribute("aria-label", APRIL_FOOLS_CONFIG.headlineText);
}

function startAprilFoolsHeadlineGuard(heroTitle) {
  if (!heroTitle || aprilFoolsObserver) return;

  aprilFoolsObserver = new MutationObserver(() => {
    if (!aprilFoolsActive) return;
    setAprilFoolsHeadline(heroTitle);
  });

  aprilFoolsObserver.observe(heroTitle, {
    childList: true,
    characterData: true,
    subtree: true
  });
}

async function createTrustedClock() {
  try {
    const serverTimestamp = await getServerTimestamp();
    const monotonicBase = performance.now();

    return {
      source: "server",
      now() {
        return new Date(
          serverTimestamp + (performance.now() - monotonicBase)
        );
      }
    };
  } catch (error) {
    console.warn("[만우절 제목] 서버 시간 확인 실패", error);

    if (!APRIL_FOOLS_CONFIG.fallbackToClientTime) {
      return null;
    }

    const clientTimestamp = Date.now();
    const monotonicBase = performance.now();

    return {
      source: "client-fallback",
      now() {
        return new Date(
          clientTimestamp + (performance.now() - monotonicBase)
        );
      }
    };
  }
}

function getTimeZoneDateParts(date) {
  try {
    const parts = new Intl.DateTimeFormat("en-US", {
      timeZone: APRIL_FOOLS_CONFIG.timeZone,
      year: "numeric",
      month: "numeric",
      day: "numeric",
      hour: "numeric",
      minute: "numeric",
      second: "numeric",
      hourCycle: "h23"
    }).formatToParts(date);

    return parts.reduce((result, part) => {
      if (part.type !== "literal") {
        result[part.type] = Number(part.value);
      }
      return result;
    }, {});
  } catch (error) {
    const koreaTime = new Date(date.getTime() + 9 * 60 * 60 * 1000);
    return {
      year: koreaTime.getUTCFullYear(),
      month: koreaTime.getUTCMonth() + 1,
      day: koreaTime.getUTCDate(),
      hour: koreaTime.getUTCHours(),
      minute: koreaTime.getUTCMinutes(),
      second: koreaTime.getUTCSeconds()
    };
  }
}

function isAprilFoolsDay(date) {
  const parts = getTimeZoneDateParts(date);
  return (
    parts.month === APRIL_FOOLS_CONFIG.month &&
    parts.day === APRIL_FOOLS_CONFIG.day
  );
}

function applyAprilFoolsTitle() {
  const heroTitle = getHeroTitle();
  if (!heroTitle) return;

  captureNormalAprilFoolsState();
  ensureAprilFoolsStyle();

  aprilFoolsActive = true;
  document.documentElement.classList.add("is-april-fools");
  setAprilFoolsHeadline(heroTitle);
  document.title = buildAprilFoolsDocumentTitle();
  startAprilFoolsHeadlineGuard(heroTitle);
}

function restoreNormalTitle() {
  const wasActive =
    aprilFoolsActive ||
    document.documentElement.classList.contains("is-april-fools");

  aprilFoolsActive = false;
  document.documentElement.classList.remove("is-april-fools");
  stopAprilFoolsHeadlineGuard();

  if (!wasActive || !aprilFoolsNormalState) return;

  const heroTitle = getHeroTitle();
  if (heroTitle) {
    heroTitle.innerHTML = aprilFoolsNormalState.headlineHtml;

    if (aprilFoolsNormalState.headlineAriaLabel === null) {
      heroTitle.removeAttribute("aria-label");
    } else {
      heroTitle.setAttribute(
        "aria-label",
        aprilFoolsNormalState.headlineAriaLabel
      );
    }
  }

  document.title = aprilFoolsNormalState.documentTitle;
}

function scheduleAprilFoolsCheck(clock) {
  if (!clock) return;

  const check = () => {
    const now = clock.now();

    if (isAprilFoolsDay(now)) {
      applyAprilFoolsTitle();
    } else {
      restoreNormalTitle();
    }

    const remainder = now.getTime() % 60000;
    const delay = Math.max(1000, 60000 - remainder + 100);
    aprilFoolsTimer = window.setTimeout(check, delay);
  };

  if (aprilFoolsTimer) {
    window.clearTimeout(aprilFoolsTimer);
  }

  check();
}

async function initAprilFoolsTitle() {
  if (!APRIL_FOOLS_CONFIG.enabled) return;

  const [clock] = await Promise.all([
    createTrustedClock(),
    waitForBrandUi()
  ]);

  captureNormalAprilFoolsState();
  scheduleAprilFoolsCheck(clock);
}