/*
    Movie App - Common Configuration
    If the app folder is renamed, update APP_NAME below and all paths
    will automatically adjust everywhere this file is included via requirepkg().
*/

// ── App identity ─────────────────────────────────────────────────────────────
var APP_NAME      = "Movie";
var BACKEND_PATH  = APP_NAME + "/backend/";

// ── Server API endpoints (relative from any page in this app) ────────────────
var MEDIA_API     = "../media";               // ?file=<vpath>  streams a file
var TRANSCODE_API  = "../media/transcode";            // ?file
var HLS_API        = "../media/hls";                  // ?file  same transcode, as an HLS playlist
var PROBE_API      = "../media/probe/";               // ?file  real codecs + playability
var STORYBOARD_API = "../media/storyboard/";          // ?file[&image=1]  scrub previews
var SUBTITLE_API   = "../media/subtitles/";           // ?file[&track=n|&font=n]  embedded tracks
var AGI_INTERFACE = "../system/ajgi/interface?script=";

// ── Script paths (used when calling ao_module_agirun from the frontend) ──────
var SCRIPT_GET_LIBRARY       = BACKEND_PATH + "getLibrary.js";
var SCRIPT_GET_LIBRARY_CACHE = BACKEND_PATH + "getLibraryCache.js";
var SCRIPT_GET_EPISODES  = BACKEND_PATH + "getEpisodes.js";
var SCRIPT_GET_THUMBNAIL = BACKEND_PATH + "getThumbnail.js";
var SCRIPT_LIST_FOLDER   = BACKEND_PATH + "listFolder.js";
var SCRIPT_GET_MOVIE_INFO     = BACKEND_PATH + "getMovieInfo.js";
var SCRIPT_DISABLE_MOVIE_INFO = BACKEND_PATH + "disableMovieInfo.js";
var SCRIPT_GET_WATCHTIME      = BACKEND_PATH + "getWatchTime.js";
var SCRIPT_SET_WATCHTIME      = BACKEND_PATH + "setWatchTime.js";
var SCRIPT_GET_INDEX_STATS    = BACKEND_PATH + "getIndexStats.js";
var SCRIPT_CLEAR_INDEX        = BACKEND_PATH + "clearIndex.js";

// ── Streaming mode ───────────────────────────────────────────────────────────
// Formats the browser cannot decode are transcoded on the fly, and there are
// two ways to deliver that transcode:
//
//   mp4  a single fragmented MP4 streamed down one response. The long-standing
//        default: it starts fastest and costs the server nothing but the ffmpeg
//        process. It cannot answer byte-range requests, which WebKit clients
//        (Safari, and every browser on iOS) require before they will play
//        anything, so on those it fails outright.
//   hls  the same transcode cut into segments behind a playlist. Every segment
//        is a finite, seekable file, so WebKit plays it and seeking inside the
//        transcoded window no longer restarts the stream.
//
// "auto" picks hls on WebKit and mp4 everywhere else (Firefox, Chrome, Edge on
// Windows and Linux). HLS exists for WebKit's sake and is not the better choice
// where MP4 works: the MP4 transcode writes into the response, so the client's
// reading pace holds ffmpeg back and closing the player ends it, while an HLS
// session writes the whole film to temp disk as fast as the CPU allows and
// outlives the player until it is reaped. Other browsers can still choose HLS
// in settings; they play it through Media Source (see nativeHLSSupported).
var STREAM_MODE_KEY = "movie_stream_mode";

// Fired on the <video> element when a Media Source HLS player loses a stream
// it had already bound (session reaped, segments failing, playback stuck),
// with event.detail.reason saying why. Pages treat it like the element's own
// 'error' event, which is how native HLS reports the same thing, and reopen
// the stream where it stopped.
var STREAM_LOST_EVENT = "transcodestreamlost";

// Identifies this player to the HLS endpoint. Seeking outside the transcoded
// window restarts the transcode at a new offset, and the server has no other
// way to tell that the previous one is finished with: the MP4 stream dies with
// its HTTP response, an HLS session does not. Without this every seek leaves
// another ffmpeg racing through the rest of the film, and after a couple of
// jumps the host is too busy to produce the segment the player is waiting for.
//
// One id per page load, so two tabs never retire each other's transcode.
// Restricted to characters the server accepts for this parameter.
var MOVIE_CLIENT_ID = "c" + Math.random().toString(36).slice(2, 10) + Date.now().toString(36);

function isWebKitClient() {
    var ua = navigator.userAgent;
    // On iOS every browser is WebKit underneath, whatever it calls itself.
    if (/CriOS|FxiOS/.test(ua)) { return true; }
    // Chrome, Edge and Opera all carry "Safari" in their desktop UA.
    if (/Chrome\/|Chromium|Edg\/|OPR\/|Firefox\//.test(ua)) { return false; }
    return /Safari/.test(ua);
}

function getStreamMode() {
    var mode = localStorage.getItem(STREAM_MODE_KEY);
    return (mode === "mp4" || mode === "hls") ? mode : "auto";
}

function setStreamMode(mode) {
    if (mode !== "mp4" && mode !== "hls") { mode = "auto"; }
    localStorage.setItem(STREAM_MODE_KEY, mode);
}

// Whether the current preference resolves to HLS for this browser.
function usingHLS() {
    var mode = getStreamMode();
    if (mode === "hls") { return true; }
    if (mode === "mp4") { return false; }
    return isWebKitClient();
}

// WebKit plays HLS natively. Everywhere else it is played through Media Source
// Extensions: hls.js if someone has vendored it into web/script/, otherwise the
// built-in MSE player in web/script/hlsmse.js, which is enough because the
// server emits single-variant fragmented-MP4 playlists.
function nativeHLSSupported(videoEl) {
    if (!videoEl || !videoEl.canPlayType) { return false; }
    if (videoEl.canPlayType("application/vnd.apple.mpegurl") === "") { return false; }
    // canPlayType alone cannot be trusted here: Chrome answers "maybe" for the
    // HLS MIME type and then fails to play the playlist. WebKit is the only
    // engine with a real native HLS pipeline, so the answer only counts there —
    // everyone else goes through Media Source instead.
    return isWebKitClient();
}

function hlsPlaybackSupported(videoEl) {
    if (nativeHLSSupported(videoEl)) { return true; }
    if (window.Hls && window.Hls.isSupported()) { return true; }
    return !!(window.MovieHLS && window.MovieHLS.isSupported());
}

// ── Direct play vs transcode ─────────────────────────────────────────────────
// The container extension is only a hint. An .mp4 may hold HEVC, AV1 or 10-bit
// H.264, none of which most browsers decode — playing those directly fails with
// a bare decode error (NS_ERROR_DOM_MEDIA_METADATA_ERR on Firefox) instead of
// being transcoded. So the server is asked what the file really contains.
var WEB_PLAYABLE_EXTENSIONS = ["mp4", "webm", "ogg", "m4v"];
var _codecProbeCache = {};

function isWebPlayableExtension(ext) {
    return WEB_PLAYABLE_EXTENSIONS.indexOf(String(ext || "").toLowerCase()) !== -1;
}

// Decide whether a file can be handed to the browser as-is. Calls back with
// true for direct play, false to transcode.
//
// Only web-native containers are probed: anything else is transcoded regardless,
// so there is nothing to learn. Results are cached per file, making repeat plays
// and episode changes free.
function resolveDirectPlay(filepath, ext, callback) {
    if (!isWebPlayableExtension(ext)) { callback(false); return; }
    if (Object.prototype.hasOwnProperty.call(_codecProbeCache, filepath)) {
        callback(_codecProbeCache[filepath]);
        return;
    }

    fetch(PROBE_API + "?file=" + encodeURIComponent(filepath), { credentials: "same-origin" })
        .then(function (r) { return r.json(); })
        .then(function (info) {
            // A probe error (no ffmpeg, remote file system) leaves the old
            // extension-based behaviour in place rather than blocking playback.
            var direct = (info && !info.error) ? !!info.directPlay : true;
            _codecProbeCache[filepath] = direct;
            callback(direct);
        })
        .catch(function () { callback(true); });
}

// Safety net for direct playback: the probe can still be wrong for a browser
// missing a platform decoder, so a decode failure retries as a transcode rather
// than leaving the viewer on a dead player.
function onDirectPlaybackFailure(videoEl, onFallback) {
    clearDirectPlaybackWatch(videoEl);
    var handler = function () {
        clearDirectPlaybackWatch(videoEl);
        var err = videoEl.error;
        // 3 = MEDIA_ERR_DECODE, 4 = MEDIA_ERR_SRC_NOT_SUPPORTED. A network
        // abort is not a codec problem and must not trigger a transcode.
        if (!err || (err.code !== 3 && err.code !== 4)) { return; }
        if (typeof onFallback === "function") { onFallback(); }
    };
    videoEl._directFallback = handler;
    videoEl.addEventListener("error", handler);
}

function clearDirectPlaybackWatch(videoEl) {
    if (videoEl && videoEl._directFallback) {
        videoEl.removeEventListener("error", videoEl._directFallback);
        videoEl._directFallback = null;
    }
}

// Build the streaming URL for a transcoded file, honouring the current mode.
// startSeconds restarts the transcode at an offset; the resulting stream always
// begins at zero, so callers track the offset separately.
function transcodeStreamURL(filepath, startSeconds) {
    var hls  = usingHLS();
    var base = hls ? HLS_API : TRANSCODE_API;
    var url  = base + "?file=" + encodeURIComponent(filepath);
    if (startSeconds && startSeconds > 0.001) {
        url += "&start=" + startSeconds.toFixed(3);
    }
    // Only HLS needs it, and the MP4 response is cacheable — a per-load
    // parameter would defeat that cache for nothing.
    if (hls) { url += "&client=" + MOVIE_CLIENT_ID; }
    return url;
}

// Fetch a playlist before handing it to the player.
//
// Answering a playlist request means starting (or joining) a transcode and
// waiting for its first segment, so it can fail long after the player has
// committed to the URL: a seek past the end of the file, a host too busy to
// produce a segment in time, a session that has already been reaped. A <video>
// element cannot tell any of that from a stream it simply cannot decode — it
// reports NotSupportedError and the reason is lost. Asking first keeps the real
// message, and hands the player a playlist that is already ready.
function preflightPlaylist(url, callback) {
    fetch(url, { credentials: "same-origin", cache: "no-store" })
        .then(function (response) {
            return response.text().then(function (body) {
                if (response.ok && String(body).trim().indexOf("#EXTM3U") === 0) {
                    callback(true);
                    return;
                }
                callback(false, playlistErrorMessage(body, response.status));
            });
        })
        .catch(function () {
            callback(false, "Transcode failed: could not reach the server");
        });
}

// Turn whatever arrived instead of a playlist into a line worth showing.
function playlistErrorMessage(body, status) {
    var text = String(body || "").trim();
    // Some endpoints still report failure as a 200 carrying a JSON error object
    if (text.charAt(0) === "{") {
        try {
            var parsed = JSON.parse(text);
            if (parsed && parsed.error) { text = String(parsed.error); }
        } catch (e) { /* not JSON after all — show it as it came */ }
    }
    if (!text) { text = "the transcode did not start (HTTP " + status + ")"; }
    if (text.length > 120) { text = text.substring(0, 119) + "…"; }
    return "Transcode failed: " + text;
}

// Point a <video> at a stream URL. HLS on a browser without native support is
// routed through hls.js when it is available. Returns false when the stream
// cannot be played at all, so the caller can say so rather than hang.
//
// A playlist is checked before the player is pointed at it, which makes the
// attachment asynchronous: onReady fires once the stream is actually bound, and
// is where the caller should call play(). onError reports a stream that never
// became playable, with the server's own explanation. A stream that fails after
// it was bound is reported on the element instead: its 'error' event for native
// playback, STREAM_LOST_EVENT for the Media Source player.
function attachTranscodeStream(videoEl, url, onError, onReady) {
    detachTranscodeStream(videoEl);

    var ready = function () { if (typeof onReady === "function") { onReady(); } };
    var fail  = function (reason, err) { if (typeof onError === "function") { onError(reason, err); } };

    if (url.indexOf(HLS_API) !== 0) {
        videoEl.src = url;
        videoEl.load();
        ready();
        return true;
    }

    // Choose the player before making a request, so a browser that cannot play
    // HLS at all is reported without waiting on a transcode it will not use.
    var bind;
    if (nativeHLSSupported(videoEl)) {
        bind = function () { videoEl.src = url; videoEl.load(); ready(); };
    } else if (window.Hls && window.Hls.isSupported()) {
        bind = function () {
            var hls = new window.Hls({ enableWorker: true });
            videoEl._hlsInstance = hls;
            hls.loadSource(url);
            hls.attachMedia(videoEl);
            ready();
        };
    } else if (window.MovieHLS && window.MovieHLS.isSupported()) {
        bind = function () {
            var instance = window.MovieHLS.attach(videoEl, url, {
                onError: function (reason, err) {
                    // A player already replaced by a newer stream is not news
                    if (videoEl._mseInstance !== instance) { return; }
                    videoEl.dispatchEvent(new CustomEvent(STREAM_LOST_EVENT, {
                        detail: { reason: reason, error: err }
                    }));
                }
            });
            videoEl._mseInstance = instance;
            ready();
        };
    } else {
        return false;
    }

    // Stop the stream being replaced now, not when the new one binds. Tearing
    // down its player does not stop the element: it plays on through whatever
    // it had buffered while the page already counts time from the new offset,
    // so after a jump to 2:20 the clock runs 2:20, 2:21, 2:22 over the old
    // picture, then snaps back to 2:20 when the new stream arrives. The gap is
    // the preflight below, which waits for the server to start ffmpeg at the
    // new offset - seconds, not milliseconds. An emptied element shows nothing
    // (the page keeps its freeze frame over it) and holds its clock at zero,
    // which is exactly the new offset.
    stopElementMedia(videoEl);

    // A seek made while the previous playlist is still being fetched must not
    // be overtaken by that older answer.
    var generation = (videoEl._streamGeneration || 0) + 1;
    videoEl._streamGeneration = generation;
    preflightPlaylist(url, function (ok, reason) {
        if (videoEl._streamGeneration !== generation) { return; }
        if (!ok) { fail(reason); return; }
        bind();
    });
    return true;
}

// Empty the element so nothing keeps playing from its old source. Removing the
// attribute (rather than setting src to "") matters: an empty src is an invalid
// source and fires 'error', which the pages would treat as a lost stream. The
// load() rejects a pending play() with AbortError, which playVideo ignores.
function stopElementMedia(videoEl) {
    if (!videoEl.hasAttribute("src")) { return; }
    videoEl.removeAttribute("src");
    videoEl.load();
}

// Release whichever player is currently bound to the element. Always call this
// before pointing a <video> somewhere new, or an MSE attachment keeps feeding
// segments into an element that has moved on.
function detachTranscodeStream(videoEl) {
    if (!videoEl) { return; }
    // Retires any playlist request still in flight for the old stream
    videoEl._streamGeneration = (videoEl._streamGeneration || 0) + 1;
    if (videoEl._hlsInstance) {
        try { videoEl._hlsInstance.destroy(); } catch (e) {}
        videoEl._hlsInstance = null;
    }
    if (videoEl._mseInstance) {
        try { videoEl._mseInstance.destroy(); } catch (e) {}
        videoEl._mseInstance = null;
    }
}

// ── Scanner settings ─────────────────────────────────────────────────────────
var VALID_VIDEO_FORMATS = ["mp4", "webm", "ogg", "mkv", "avi", "mov", "m4v", "wmv", "flv", "rmvb", "ts"];
var SKIP_ROOT_PREFIXES  = ["tmp:/", "trash:/"];    // roots to skip entirely
var VIDEO_FOLDER_NAME   = "Video";                 // expected folder inside each root
var MOVIE_FOLDER_NAMES  = ["movie", "movies"];     // folder names (case-insensitive) treated as movie containers
var ANIME_FOLDER_NAMES  = ["anime"];               // folder names (case-insensitive) treated as anime containers