data.js

/**
 * @file data.js
 * @description Load and search movie showings from jsonShows/*.json
 * @author G.E. Eidsness	
 * @version $Revision: 009 $
 * $Date: 2013-09-16 12:01:39 -0700 (Mon, 16 Sept 2013) $
 * @version $Revisions: 003 $
 * $Date: 2023-11-17 00:46:39 -0700 (Fri, 17 Nov 2023) $
 * $Date: 2024-09-29 10:06:39 -0700 (Mon, 29 Sept 2024) $
 * @version $Rewrite: 001 $
 * $Date: 2026-07-28 11:36:29 -0700 (Tue, 28 July 2026) $
*/

/**
 * @typedef {Object} Showing
 * @property {Date|string} date
 * @property {string} title
 * @property {number} dur
 * @property {string} descr
 */

export const baseURL = "./jsonShows/";

/** @type {Object.<string, Object.<string, Showing>>} */
export let jsonShowings = { blank: {} };

/**
 * @param {string|number} n
 * @returns {string}
 */
export const pad2 = (n) => String(n).padStart(2, "0");

/**
 * @param {string|number} year
 * @param {string|number} month1Based
 * @returns {string}
 */
export const monthJsonUrl = (year, month1Based) =>
  `${baseURL}${year}_${pad2(month1Based)}.json`;

/**
 * @param {string} jsonFile
 * @returns {{ year: string, monthNum: number }}
 */
const parseYearMonthFromUrl = (jsonFile) => {
  const parts = jsonFile.split("/").pop().split(".")[0].split("_");
  return { year: parts[0], monthNum: parseInt(parts[1], 10) };
};

/**
 * @param {string|number} year
 * @param {string|number} month1Based
 * @returns {string}
 */
const monthName = (year, month1Based) =>
  new Date(year, month1Based - 1).toLocaleString("default", { month: "long" });

/**
 * Convert showing date strings from JSON into Date objects (in place).
 * @param {Object.<string, Object.<string, Showing>>} data
 */
const adjustDateFormat = (data) => {
  Object.values(data).forEach((day) => {
    Object.values(day).forEach((showing) => {
      if (showing && showing.date) {
        showing.date = new Date(showing.date);
      }
    });
  });
};

/**
 * @param {Date} date
 * @returns {Promise<boolean>}
 */
export const isDataAvailable = async (date) => {
  const url = monthJsonUrl(date.getFullYear(), date.getMonth() + 1);
  try {
    let response = await fetch(url, { method: "HEAD" });
    // Some static hosts disallow HEAD; fall back to GET.
    if (response.status === 405 || response.status === 501) {
      response = await fetch(url, { method: "GET" });
    }
    return response.ok;
  } catch {
    return false;
  }
};

/**
 * @param {string|number} year
 * @param {string|number} month1Based
 * @returns {Promise<Date|null>}
 */
export const findClosestAvailableDate = async (year, month1Based) => {
  const currentDate = new Date(Number(year), Number(month1Based) - 1);
  const futureDate = new Date(currentDate);
  const pastDate = new Date(currentDate);
  const maxAttempts = 12;

  for (let i = 0; i < maxAttempts; i++) {
    futureDate.setMonth(futureDate.getMonth() + 1);
    if (await isDataAvailable(futureDate)) return futureDate;

    pastDate.setMonth(pastDate.getMonth() - 1);
    if (await isDataAvailable(pastDate)) return pastDate;
  }
  return null;
};

/**
 * Load a month JSON file into jsonShowings.
 * On 404, offers the closest available month (confirm dialog).
 *
 * @param {string} jsonFile
 * @returns {Promise<{ ok: boolean, navigateTo: Date|null }>}
 *   navigateTo is set when the user accepts a fallback month (day 1).
 */
export const loadShowings = async (jsonFile) => {
  const { year, monthNum } = parseYearMonthFromUrl(jsonFile);
  const label = `${monthName(year, monthNum)} ${year}`;

  try {
    const response = await fetch(jsonFile);

    if (response.status === 404) {
      const closestDate = await findClosestAvailableDate(year, monthNum);
      if (closestDate) {
        const closestLabel = `${closestDate.toLocaleString("default", {
          month: "long",
        })} ${closestDate.getFullYear()}`;
        const userChoice = confirm(
          `Data for ${label} is not available. Click OK to view ${closestLabel}.`
        );
        if (userChoice) {
          const newJsonFile = monthJsonUrl(
            closestDate.getFullYear(),
            closestDate.getMonth() + 1
          );
          await loadShowings(newJsonFile);
          return { ok: true, navigateTo: closestDate };
        }
      } else {
        alert(`No available data found near ${label}.`);
      }
      jsonShowings = { blank: {} };
      return { ok: false, navigateTo: null };
    }

    if (!response.ok) {
      alert(`Error loading data for ${label}`);
      console.error("HTTP error! status:", response.status);
      jsonShowings = { blank: {} };
      return { ok: false, navigateTo: null };
    }

    jsonShowings = await response.json();
    adjustDateFormat(jsonShowings);
    return { ok: true, navigateTo: null };
  } catch (error) {
    alert(`Error loading month data for ${label}`);
    console.error("loadShowings() error:", error);
    jsonShowings = { blank: {} };
    return { ok: false, navigateTo: null };
  }
};

/**
 * Search a month JSON for title/description matches.
 * @param {string} url
 * @param {string} term
 * @param {string} [searchType="title"] "title" | "descr"
 * @returns {Promise<Array<{title: string, date: string}>>}
 */
export const fetchAsyncListing = async (url, term, searchType = "title") => {
  const matched = [];
  const needle = term.toLowerCase();
  if (!needle) return matched;

  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();

    for (const dateKey of Object.keys(data)) {
      const listings = data[dateKey];
      for (const listingKey of Object.keys(listings)) {
        const item = listings[listingKey];
        const field = (item[searchType] || "").toLowerCase();
        if (field.includes(needle)) {
          matched.push({
            title: item.title,
            date: item.date,
          });
        }
      }
    }
    return matched;
  } catch (error) {
    console.error("fetchAsyncListing error:", error);
    return [];
  }
};