"use strict";

var testHttpClient = null;
var testConfig = null;
var defaultClient = null;
var defaultClientSignature = null;
var activeBaseUrlCache = null;

var SEARCH_PAGE_SIZE = 20;
var LIST_PAGE_SIZE = 60;
var ACTIVE_BASE_URL_CACHE_MS = 5 * 60 * 1000;
var LAN_PROBE_TIMEOUT_MS = 800;
var PLUGIN_SRC_PLACEHOLDER = ["__MUSIC", "_SERVER", "_PLUGIN", "_SRC_URL__"].join("");
var DEFAULT_PLUGIN_SRC_URL = "__MUSIC_SERVER_PLUGIN_SRC_URL__";

function hasOwn(obj, key) {
    return Object.prototype.hasOwnProperty.call(obj, key);
}

function toTrimmedString(value) {
    if (value === null || value === undefined) {
        return "";
    }
    return String(value).trim();
}

function normalizeBaseUrl(url) {
    var value = toTrimmedString(url);
    if (!value) {
        return "";
    }
    return value.replace(/\/+$/, "");
}

function isPluginSrcPlaceholder(value) {
    return toTrimmedString(value) === PLUGIN_SRC_PLACEHOLDER;
}

function normalizeAccessToken(value) {
    var token = toTrimmedString(value);
    if (!token) {
        return "";
    }
    return token.replace(/^Bearer\s+/i, "").trim();
}

function createFallbackClientId(accessToken) {
    var token = normalizeAccessToken(accessToken);
    var hash = 0;
    var i = 0;
    var unsigned = 0;

    if (!token) {
        return "";
    }

    for (i = 0; i < token.length; i += 1) {
        hash = ((hash << 5) - hash + token.charCodeAt(i)) | 0;
    }
    unsigned = hash >>> 0;
    return "mf-fallback-" + unsigned.toString(16);
}

function getRuntimeEnv() {
    if (typeof env !== "undefined" && env) {
        return env;
    }
    return null;
}

function readConfigValue(key) {
    var runtimeEnv = null;
    var variablesFromGetter = null;
    var variables = null;
    var i = 0;
    var item = null;

    try {
        if (testConfig && hasOwn(testConfig, key)) {
            return testConfig[key];
        }

        runtimeEnv = getRuntimeEnv();
        if (!runtimeEnv || typeof runtimeEnv !== "object") {
            return undefined;
        }

        if (typeof runtimeEnv.getUserVariables === "function") {
            try {
                variablesFromGetter = runtimeEnv.getUserVariables();
                if (
                    variablesFromGetter &&
                    typeof variablesFromGetter === "object" &&
                    hasOwn(variablesFromGetter, key)
                ) {
                    return variablesFromGetter[key];
                }
                if (Array.isArray(variablesFromGetter)) {
                    for (i = 0; i < variablesFromGetter.length; i += 1) {
                        item = variablesFromGetter[i];
                        if (
                            item &&
                            typeof item === "object" &&
                            toTrimmedString(item.key) === key &&
                            hasOwn(item, "value")
                        ) {
                            return item.value;
                        }
                    }
                }
            } catch (_error) {
                variablesFromGetter = null;
            }
        }

        try {
            variables = runtimeEnv.userVariables;
        } catch (_error2) {
            variables = null;
        }
        if (variables && typeof variables === "object" && hasOwn(variables, key)) {
            return variables[key];
        }
        if (Array.isArray(variables)) {
            for (i = 0; i < variables.length; i += 1) {
                item = variables[i];
                if (
                    item &&
                    typeof item === "object" &&
                    toTrimmedString(item.key) === key &&
                    hasOwn(item, "value")
                ) {
                    return item.value;
                }
            }
        }
    } catch (_error3) {
        return undefined;
    }

    return undefined;
}

function readFirstConfigValue(keys) {
    var i = 0;
    var value = undefined;

    for (i = 0; i < keys.length; i += 1) {
        value = readConfigValue(keys[i]);
        if (value === undefined || value === null) {
            continue;
        }
        if (toTrimmedString(value)) {
            return value;
        }
    }

    return undefined;
}

function readPluginSrcUrl() {
    var explicitSrcUrl = readFirstConfigValue(["srcUrl"]);
    if (explicitSrcUrl) {
        return explicitSrcUrl;
    }
    if (
        typeof module !== "undefined" &&
        module &&
        module.exports &&
        typeof module.exports.srcUrl === "string"
    ) {
        return module.exports.srcUrl;
    }
    return DEFAULT_PLUGIN_SRC_URL;
}

function normalizeConfiguredBaseUrl(value) {
    var raw = toTrimmedString(value);
    var withScheme = "";
    var parsed = null;
    var pathname = "";
    var fallbackRaw = "";

    if (!raw || isPluginSrcPlaceholder(raw)) {
        return "";
    }

    if (/^[a-z][a-z\d+\-.]*:\/\//i.test(raw)) {
        withScheme = raw;
    } else {
        withScheme = "http://" + raw;
    }

    try {
        parsed = new URL(withScheme);
        parsed.hash = "";
        pathname = parsed.pathname || "";
        if (/\/plugins\/[^/]+\.js$/i.test(pathname)) {
            parsed.pathname = pathname.replace(/\/plugins\/[^/]+\.js$/i, "") || "/";
            parsed.search = "";
        }
        return normalizeBaseUrl(parsed.toString());
    } catch (_error) {
        fallbackRaw = withScheme.replace(/\/plugins\/[^/?#]+\.js(?:[?#].*)?$/i, "");
        return normalizeBaseUrl(fallbackRaw);
    }
}

function resolvePublicBaseUrl() {
    var configured = normalizeConfiguredBaseUrl(
        readFirstConfigValue(["baseUrl", "baseURL", "serverUrl", "serverURL"]),
    );
    var fromSrcUrl = normalizeConfiguredBaseUrl(readPluginSrcUrl());

    if (configured) {
        return configured;
    }
    if (fromSrcUrl) {
        return fromSrcUrl;
    }
    return "";
}

function resolveLanBaseUrl() {
    return normalizeConfiguredBaseUrl(
        readFirstConfigValue([
            "lanBaseUrl",
            "lanBaseURL",
            "localBaseUrl",
            "localBaseURL",
        ]),
    );
}

function resolveBaseUrl() {
    var snapshot = buildConfigSnapshot();
    var signature = getConfigSignature(snapshot);

    if (
        activeBaseUrlCache &&
        activeBaseUrlCache.signature === signature &&
        activeBaseUrlCache.baseUrl
    ) {
        return activeBaseUrlCache.baseUrl;
    }
    return snapshot.publicBaseUrl || snapshot.baseUrl || "";
}

function readRuntimeValue(key) {
    var runtimeEnv = null;
    var runtimeValues = null;

    try {
        if (testConfig && hasOwn(testConfig, key)) {
            return testConfig[key];
        }

        runtimeEnv = getRuntimeEnv();
        if (!runtimeEnv) {
            return undefined;
        }

        if (typeof runtimeEnv.getRuntimeValue === "function") {
            try {
                return runtimeEnv.getRuntimeValue(key);
            } catch (_error) {
                return undefined;
            }
        }

        try {
            runtimeValues = runtimeEnv.runtimeValues;
        } catch (_error2) {
            runtimeValues = null;
        }
        if (runtimeValues && typeof runtimeValues === "object") {
            return runtimeValues[key];
        }
    } catch (_error3) {
        return undefined;
    }

    return undefined;
}

function buildConfigSnapshot() {
    var accessToken = normalizeAccessToken(
        readFirstConfigValue([
            "accessToken",
            "token",
            "authToken",
            "authorization",
            "Authorization",
        ]),
    );
    var publicBaseUrl = resolvePublicBaseUrl();
    var lanBaseUrl = resolveLanBaseUrl();

    return {
        publicBaseUrl: publicBaseUrl,
        baseUrl: publicBaseUrl,
        lanBaseUrl: lanBaseUrl,
        accessToken: accessToken,
        runtimeClientId: String(
            readConfigValue("runtimeClientId") ||
                readRuntimeValue("runtimeClientId") ||
                createFallbackClientId(accessToken) ||
                "",
        ),
        runtimeClientLabel: String(
            readConfigValue("runtimeClientLabel") ||
                readRuntimeValue("runtimeClientLabel") ||
                "",
        ),
    };
}

function getConfigSignature(snapshot) {
    return [
        snapshot.publicBaseUrl || snapshot.baseUrl,
        snapshot.lanBaseUrl,
        snapshot.baseUrl,
        snapshot.accessToken,
        snapshot.runtimeClientId,
        snapshot.runtimeClientLabel,
    ].join("|");
}

function buildClientHeaders(snapshot) {
    var currentSnapshot = snapshot || buildConfigSnapshot();
    var headers = {};

    if (currentSnapshot.accessToken) {
        headers.Authorization = "Bearer " + currentSnapshot.accessToken;
    }
    if (currentSnapshot.runtimeClientId) {
        headers["X-Music-Client-Id"] = currentSnapshot.runtimeClientId;
    }
    if (currentSnapshot.runtimeClientLabel) {
        headers["X-Music-Client-Label"] = currentSnapshot.runtimeClientLabel;
    }
    return headers;
}

function appendQueryParams(url, params) {
    var pairs = [];
    var key = "";
    var value = null;
    var query = "";

    if (!params || typeof params !== "object") {
        return url;
    }

    for (key in params) {
        if (!hasOwn(params, key)) {
            continue;
        }
        value = params[key];
        if (value === undefined || value === null) {
            continue;
        }
        pairs.push(
            encodeURIComponent(key) + "=" + encodeURIComponent(String(value)),
        );
    }

    if (pairs.length === 0) {
        return url;
    }

    query = pairs.join("&");
    if (!query) {
        return url;
    }

    if (url.indexOf("?") !== -1) {
        return url + "&" + query;
    }
    return url + "?" + query;
}

function copyObject(source) {
    var target = {};
    var key = "";

    if (!source || typeof source !== "object") {
        return target;
    }

    for (key in source) {
        if (hasOwn(source, key)) {
            target[key] = source[key];
        }
    }
    return target;
}

function joinWithSpecificBaseUrl(baseUrl, path) {
    var rawPath = toTrimmedString(path);
    var currentBaseUrl = normalizeBaseUrl(baseUrl);
    var protocol = "";

    if (!rawPath) {
        return "";
    }
    if (isAbsoluteUrl(rawPath)) {
        return rawPath;
    }
    if (rawPath.indexOf("//") === 0) {
        protocol = getUrlProtocol(currentBaseUrl);
        if (!protocol) {
            return rawPath;
        }
        return protocol + rawPath;
    }
    if (!currentBaseUrl) {
        return rawPath;
    }
    if (rawPath.charAt(0) === "/") {
        return currentBaseUrl + rawPath;
    }
    return currentBaseUrl + "/" + rawPath;
}

function cacheResolvedBaseUrl(snapshot, baseUrl) {
    activeBaseUrlCache = {
        signature: getConfigSignature(snapshot),
        baseUrl: normalizeBaseUrl(baseUrl),
        expiresAt: Date.now() + ACTIVE_BASE_URL_CACHE_MS,
    };
}

async function probeLanBaseUrl(lanBaseUrl) {
    var controller = null;
    var timeoutId = null;
    var response = null;

    if (!lanBaseUrl || typeof fetch !== "function") {
        return false;
    }

    try {
        if (typeof AbortController === "function") {
            controller = new AbortController();
            timeoutId = setTimeout(function abortProbe() {
                controller.abort();
            }, LAN_PROBE_TIMEOUT_MS);
        }
        response = await fetch(joinWithSpecificBaseUrl(lanBaseUrl, "/healthz"), {
            method: "GET",
            signal: controller ? controller.signal : undefined,
        });
        return !!(response && response.ok);
    } catch (_error) {
        return false;
    } finally {
        if (timeoutId !== null) {
            clearTimeout(timeoutId);
        }
    }
}

async function resolveActiveBaseUrl(snapshot) {
    var currentSnapshot = snapshot || buildConfigSnapshot();
    var signature = getConfigSignature(currentSnapshot);
    var currentTime = Date.now();
    var selectedBaseUrl = "";
    var lanAvailable = false;

    if (
        activeBaseUrlCache &&
        activeBaseUrlCache.signature === signature &&
        activeBaseUrlCache.expiresAt > currentTime &&
        activeBaseUrlCache.baseUrl
    ) {
        return activeBaseUrlCache.baseUrl;
    }

    if (
        currentSnapshot.lanBaseUrl &&
        currentSnapshot.lanBaseUrl !== currentSnapshot.publicBaseUrl
    ) {
        lanAvailable = await probeLanBaseUrl(currentSnapshot.lanBaseUrl);
    }

    selectedBaseUrl = lanAvailable
        ? currentSnapshot.lanBaseUrl
        : currentSnapshot.publicBaseUrl || currentSnapshot.lanBaseUrl || "";
    cacheResolvedBaseUrl(currentSnapshot, selectedBaseUrl);
    return selectedBaseUrl;
}

function createFetchClient(snapshot) {
    if (typeof fetch !== "function") {
        throw new Error("http_client_unavailable");
    }

    async function request(method, path, options) {
        var opts = options || {};
        var currentSnapshot = snapshot || buildConfigSnapshot();
        var baseUrl = await resolveActiveBaseUrl(currentSnapshot);
        var url = joinWithSpecificBaseUrl(baseUrl, path);
        var headers = copyObject(buildClientHeaders(currentSnapshot));
        var body = undefined;
        var response = null;
        var text = "";
        var payload = {};

        url = appendQueryParams(url, opts.params);
        if (opts.data !== undefined) {
            headers["Content-Type"] = "application/json";
            body = JSON.stringify(opts.data);
        }

        response = await fetch(url, {
            method: method,
            headers: headers,
            body: body,
        });
        text = await response.text();
        if (text) {
            try {
                payload = JSON.parse(text);
            } catch (_error) {
                payload = text;
            }
        }

        if (!response.ok) {
            throw new Error("http_" + response.status);
        }

        return { data: payload };
    }

    return {
        get: function get(path, config) {
            return request("GET", path, { params: config && config.params });
        },
        post: function post(path, data) {
            return request("POST", path, { data: data });
        },
    };
}

function createDefaultClient(snapshot) {
    var currentSnapshot = snapshot || buildConfigSnapshot();
    return createFetchClient(currentSnapshot);
}

function getClient() {
    var snapshot = null;
    var signature = "";

    if (testHttpClient) {
        return testHttpClient;
    }

    snapshot = buildConfigSnapshot();
    signature = getConfigSignature(snapshot);

    if (!defaultClient || defaultClientSignature !== signature) {
        defaultClient = createDefaultClient(snapshot);
        defaultClientSignature = signature;
    }

    return defaultClient;
}

function __setHttpClientForTests(client) {
    testHttpClient = client || null;
}

function __setConfigForTests(config) {
    testConfig = config || null;
    defaultClient = null;
    defaultClientSignature = null;
    activeBaseUrlCache = null;
}

function __clearTestState() {
    testHttpClient = null;
    testConfig = null;
    defaultClient = null;
    defaultClientSignature = null;
    activeBaseUrlCache = null;
}

function toPositivePage(page) {
    var value = Number(page);
    if (!isFinite(value) || value <= 0) {
        return 1;
    }
    return Math.floor(value);
}

function toNonNegativeInt(value) {
    var parsed = Number(value);
    if (!isFinite(parsed) || parsed < 0) {
        return null;
    }
    return Math.floor(parsed);
}

function normalizeDuration(value) {
    var parsed = Number(value);
    if (!isFinite(parsed) || parsed <= 0) {
        return 0;
    }
    if (parsed > 1000) {
        return Math.round(parsed / 1000);
    }
    return Math.round(parsed);
}

function pickArrayField(obj, fieldNames) {
    var i = 0;
    var fieldName = "";

    if (!obj || typeof obj !== "object") {
        return null;
    }

    for (i = 0; i < fieldNames.length; i += 1) {
        fieldName = fieldNames[i];
        if (Array.isArray(obj[fieldName])) {
            return obj[fieldName];
        }
    }
    return null;
}

function extractList(payload) {
    var list = null;

    if (Array.isArray(payload)) {
        return payload;
    }
    if (!payload || typeof payload !== "object") {
        return [];
    }

    list = pickArrayField(payload, [
        "data",
        "musicList",
        "items",
        "list",
        "rows",
        "songs",
        "tracks",
        "toplists",
    ]);
    if (list) {
        return list;
    }

    if (payload.data && typeof payload.data === "object") {
        return extractList(payload.data);
    }

    return [];
}

function joinArtists(value) {
    var parts = [];
    var i = 0;
    var item = null;
    var part = "";

    if (Array.isArray(value)) {
        for (i = 0; i < value.length; i += 1) {
            item = value[i];
            if (typeof item === "string") {
                part = toTrimmedString(item);
            } else if (item && typeof item === "object") {
                part = toTrimmedString(item.name || item.artist || item.title);
            } else {
                part = "";
            }
            if (part) {
                parts.push(part);
            }
        }
        return parts.join(", ");
    }

    if (value && typeof value === "object") {
        return toTrimmedString(value.name || value.artist || value.title);
    }

    return toTrimmedString(value);
}

function parsePublicId(publicId) {
    var raw = toTrimmedString(publicId);
    var segments = [];

    if (!raw) {
        return "";
    }

    segments = raw.split(":");
    if (!segments.length) {
        return raw;
    }
    return segments[segments.length - 1];
}

function parsePublicItemRef(publicId) {
    var raw = toTrimmedString(publicId);
    var segments = [];

    if (!raw) {
        return { kind: "", id: "" };
    }

    segments = raw.split(":");
    if (segments.length >= 3 && segments[0] === "catalogsync") {
        return {
            kind: toTrimmedString(segments[1]),
            id: toTrimmedString(segments.slice(2).join(":")),
        };
    }

    return {
        kind: "",
        id: parsePublicId(raw),
    };
}

function mapMusicItem(item) {
    var albumRaw = {};
    var id = "";
    var title = "";
    var album = "";
    var artwork = "";
    var artist = "";
    var duration = 0;

    if (!item || typeof item !== "object") {
        return null;
    }

    if (item.album && typeof item.album === "object") {
        albumRaw = item.album;
    }

    id = toTrimmedString(item.id || item.songId || item.song_id || item.musicId);
    title = toTrimmedString(item.title || item.name || item.songName);
    if (!id && !title) {
        return null;
    }

    if (typeof item.album === "string") {
        album = toTrimmedString(item.album);
    } else {
        album = toTrimmedString(albumRaw.name || albumRaw.title);
    }
    artwork = toTrimmedString(
        item.artwork ||
            item.coverImg ||
            item.cover ||
            item.picUrl ||
            albumRaw.artwork ||
            albumRaw.coverImg ||
            albumRaw.cover ||
            albumRaw.picUrl,
    );
    artist = joinArtists(item.artist || item.artists || item.ar || item.singers);
    duration = normalizeDuration(
        item.duration ||
            item.durationSec ||
            item.duration_sec ||
            item.length ||
            item.dt,
    );

    return {
        id: id || title,
        title: title,
        artist: artist,
        album: album,
        artwork: artwork,
        duration: duration,
    };
}

function mapSheetItem(item) {
    var id = "";
    var result = {};
    var title = "";
    var artist = "";
    var description = "";
    var coverImg = "";
    var worksNumValue = null;
    var playableWorksNumRaw = null;
    var playableWorksNumValue = null;
    var playCountValue = null;

    if (!item || typeof item !== "object") {
        return null;
    }

    id = toTrimmedString(item.id || item.sheetId || item.playlistId);
    if (!id) {
        return null;
    }

    result.id = id;

    title = toTrimmedString(item.title || item.name);
    artist = toTrimmedString(
        item.artist ||
            (item.creator && item.creator.nickname) ||
            (item.owner && item.owner.nickname) ||
            item.updateFrequency,
    );
    description = toTrimmedString(item.description || item.desc);
    coverImg = toTrimmedString(
        item.coverImg ||
            item.cover ||
            item.artwork ||
            item.picUrl ||
            item.coverImgUrl,
    );
    worksNumValue = toNonNegativeInt(item.worksNum || item.trackCount || item.musicCount);
    if (item.playableWorksNum !== null && item.playableWorksNum !== undefined) {
        playableWorksNumRaw = item.playableWorksNum;
    } else {
        playableWorksNumRaw = item.playableSongCount;
    }
    playableWorksNumValue = toNonNegativeInt(playableWorksNumRaw);
    playCountValue = toNonNegativeInt(item.play_count);

    if (title) {
        result.title = title;
    }
    if (artist) {
        result.artist = artist;
    }
    if (description) {
        result.description = description;
    }
    if (coverImg) {
        result.coverImg = coverImg;
    }
    if (worksNumValue !== null) {
        result.worksNum = worksNumValue;
    }
    if (playableWorksNumValue !== null) {
        result.playableWorksNum = playableWorksNumValue;
    }
    if (playCountValue !== null) {
        result.play_count = playCountValue;
    }

    return result;
}

function mapArtistItem(item) {
    var id = "";
    var name = "";
    var worksNum = null;

    if (!item || typeof item !== "object") {
        return null;
    }

    id = toTrimmedString(item.id || item.artistId || item.artist_id);
    name = toTrimmedString(item.name || item.title);
    if (!id && !name) {
        return null;
    }

    worksNum = toNonNegativeInt(item.worksNum || item.musicCount || item.playableSongCount);

    return {
        id: id || name,
        name: name || id,
        avatar: toTrimmedString(item.avatar || item.avatarUrl || item.coverImg || item.artwork),
        description: toTrimmedString(item.description || item.desc),
        worksNum: worksNum !== null ? worksNum : 0,
        platform: toTrimmedString(item.platform || "catalogsync"),
        supportedArtistTabs: Array.isArray(item.supportedArtistTabs)
            ? item.supportedArtistTabs
            : ["music"],
    };
}

function mapTagItem(item) {
    var id = "";
    var title = "";

    if (!item || typeof item !== "object") {
        return null;
    }

    id = toTrimmedString(item.id || item.value || item.key || item.name);
    title = toTrimmedString(item.title || item.name || item.label || id);
    if (!id && !title) {
        return null;
    }

    return {
        id: id || title,
        title: title || id,
    };
}

function mapTopListGroup(group, fallbackTitle) {
    var rawItems = [];
    var items = [];
    var i = 0;
    var mapped = null;
    var title = "";

    if (!group || typeof group !== "object") {
        return null;
    }

    rawItems = pickArrayField(group, ["data", "items", "list", "toplists"]) || [];
    for (i = 0; i < rawItems.length; i += 1) {
        mapped = mapSheetItem(rawItems[i]);
        if (mapped) {
            items.push(mapped);
        }
    }
    if (!items.length) {
        return null;
    }

    title = toTrimmedString(group.title || group.name || fallbackTitle);
    return {
        title: title,
        data: items,
    };
}

function normalizeTopListGroups(payload) {
    var source = payload && typeof payload === "object" ? payload : {};
    var baseList = null;
    var first = null;
    var firstIsGroup = false;
    var groups = [];
    var i = 0;
    var group = null;
    var mapped = null;
    var data = [];
    var row = null;

    if (Array.isArray(payload)) {
        baseList = payload;
    } else {
        baseList = pickArrayField(source, ["data", "groups", "list"]);
    }

    if (!Array.isArray(baseList) || !baseList.length) {
        return [];
    }

    first = baseList[0];
    firstIsGroup = !!(
        first &&
        typeof first === "object" &&
        pickArrayField(first, ["data", "items", "list", "toplists"])
    );

    if (firstIsGroup) {
        for (i = 0; i < baseList.length; i += 1) {
            mapped = mapTopListGroup(baseList[i], "");
            if (mapped) {
                groups.push(mapped);
            }
        }
        return groups;
    }

    for (i = 0; i < baseList.length; i += 1) {
        row = mapSheetItem(baseList[i]);
        if (row) {
            data.push(row);
        }
    }
    group = {
        title: toTrimmedString(source.title || source.name),
        data: data,
    };
    return [group];
}

function resolveIsEnd(payload, page, pageSize, listLength) {
    var total = null;

    if (payload && typeof payload === "object") {
        if (typeof payload.isEnd === "boolean") {
            return payload.isEnd;
        }
        if (typeof payload.is_end === "boolean") {
            return payload.is_end;
        }
        if (typeof payload.more === "boolean") {
            return !payload.more;
        }

        total = Number(
            payload.total ||
                payload.count ||
                payload.totalCount ||
                payload.total_count,
        );
        if (isFinite(total) && total >= 0) {
            return page * pageSize >= total;
        }
    }

    return listLength < pageSize;
}

async function requestGet(path, params) {
    var client = getClient();
    var response = await client.get(path, params ? { params: params } : undefined);

    if (
        response &&
        typeof response === "object" &&
        hasOwn(response, "data")
    ) {
        return response.data || {};
    }
    return response || {};
}

async function requestPost(path, data) {
    var client = getClient();
    var response = await client.post(path, data);

    if (
        response &&
        typeof response === "object" &&
        hasOwn(response, "data")
    ) {
        return response.data || {};
    }
    return response || {};
}

async function getPluginStatus() {
    try {
        var payload = await requestGet("/auth/v1/token-status");
        if (payload && typeof payload === "object") {
            return payload;
        }
        return null;
    } catch (_error) {
        return null;
    }
}

function isAbsoluteUrl(url) {
    return /^[a-z][a-z\d+\-.]*:\/\//i.test(toTrimmedString(url));
}

function getUrlProtocol(url) {
    var matched = toTrimmedString(url).match(/^([a-z][a-z\d+\-.]*:)/i);
    return matched ? matched[1] : "";
}

function joinWithBaseUrl(path) {
    return joinWithSpecificBaseUrl(resolveBaseUrl(), path);
}

function normalizeTagValue(tag) {
    if (tag && typeof tag === "object") {
        if (hasOwn(tag, "id")) {
            return toTrimmedString(tag.id);
        }
        return toTrimmedString(tag.value || tag.title || tag.name);
    }
    return toTrimmedString(tag);
}

async function getMediaSource(musicItem, quality) {
    var payload = null;
    var stream = null;
    var streamUrl = "";

    try {
        payload = await requestPost("/mf/v1/media/resolve", {
            song_id: musicItem && musicItem.id,
            quality: quality,
        });
        if (payload && payload.stream && typeof payload.stream === "object") {
            stream = payload.stream;
        }
        streamUrl = joinWithBaseUrl(stream && stream.url);
        if (!streamUrl) {
            return null;
        }

        return {
            url: streamUrl,
            headers:
                stream && stream.headers && typeof stream.headers === "object"
                    ? stream.headers
                    : {},
            quality: toTrimmedString(
                payload &&
                    payload.selected_source &&
                    payload.selected_source.quality,
            ) || quality,
        };
    } catch (_error) {
        return null;
    }
}

async function search(query, page, type) {
    var normalizedPage = 1;
    var endpoint = "";
    var payload = null;
    var rawList = [];
    var data = [];
    var i = 0;
    var mapped = null;
    var mapper = null;

    if (type === "music") {
        endpoint = "/mf/v1/search/songs";
        mapper = mapMusicItem;
    } else if (type === "artist") {
        endpoint = "/mf/v1/search/artists";
        mapper = mapArtistItem;
    } else if (type === "sheet") {
        endpoint = "/mf/v1/search/sheets";
        mapper = mapSheetItem;
    } else {
        return {
            isEnd: true,
            data: [],
        };
    }

    try {
        normalizedPage = toPositivePage(page);
        payload = await requestGet(endpoint, {
            q: toTrimmedString(query),
            page: normalizedPage,
            page_size: SEARCH_PAGE_SIZE,
        });
        rawList = extractList(payload);
        for (i = 0; i < rawList.length; i += 1) {
            mapped = mapper(rawList[i]);
            if (mapped) {
                data.push(mapped);
            }
        }

        return {
            isEnd: resolveIsEnd(payload, normalizedPage, SEARCH_PAGE_SIZE, rawList.length),
            data: data,
        };
    } catch (_error) {
        return {
            isEnd: true,
            data: [],
        };
    }
}

async function getRecommendSheetTags() {
    var payload = null;
    var source = {};
    var pinnedRaw = [];
    var groupsRaw = [];
    var pinned = [];
    var groups = [];
    var i = 0;
    var j = 0;
    var mapped = null;
    var group = null;
    var groupData = [];

    try {
        payload = await requestGet("/mf/v1/recommend/tags");
        source = payload && typeof payload === "object" ? payload : {};

        if (Array.isArray(source.pinned)) {
            pinnedRaw = source.pinned;
        } else if (Array.isArray(source.hot)) {
            pinnedRaw = source.hot;
        }
        for (i = 0; i < pinnedRaw.length; i += 1) {
            mapped = mapTagItem(pinnedRaw[i]);
            if (mapped) {
                pinned.push(mapped);
            }
        }

        if (Array.isArray(source.data)) {
            groupsRaw = source.data;
        } else if (Array.isArray(source.groups)) {
            groupsRaw = source.groups;
        }
        for (i = 0; i < groupsRaw.length; i += 1) {
            group = groupsRaw[i];
            groupData = [];
            if (group && Array.isArray(group.data)) {
                for (j = 0; j < group.data.length; j += 1) {
                    mapped = mapTagItem(group.data[j]);
                    if (mapped) {
                        groupData.push(mapped);
                    }
                }
            }
            groups.push({
                title: toTrimmedString(group && (group.title || group.name)),
                data: groupData,
            });
        }

        return {
            pinned: pinned,
            data: groups,
        };
    } catch (_error) {
        return {
            pinned: [],
            data: [],
        };
    }
}

async function getRecommendSheetsByTag(tag, page) {
    var normalizedPage = toPositivePage(page);
    var payload = null;
    var rawList = [];
    var data = [];
    var i = 0;
    var mapped = null;

    try {
        payload = await requestGet("/mf/v1/recommend/sheets", {
            tag: normalizeTagValue(tag) || "all",
            page: normalizedPage,
            page_size: LIST_PAGE_SIZE,
        });
        rawList = extractList(payload);
        for (i = 0; i < rawList.length; i += 1) {
            mapped = mapSheetItem(rawList[i]);
            if (mapped) {
                data.push(mapped);
            }
        }

        return {
            isEnd: resolveIsEnd(payload, normalizedPage, LIST_PAGE_SIZE, rawList.length),
            data: data,
        };
    } catch (_error) {
        return {
            isEnd: true,
            data: [],
        };
    }
}

async function getMusicSheetInfo(sheetItem, page) {
    var normalizedPage = toPositivePage(page);
    var sourceItem = sheetItem && typeof sheetItem === "object" ? sheetItem : {};
    var itemRef = parsePublicItemRef(sourceItem.id);
    var mappedSheetItem = mapSheetItem(sourceItem);
    var endpointBase = "";
    var detail = null;
    var tracksPayload = null;
    var rawList = [];
    var musicList = [];
    var i = 0;
    var mapped = null;
    var result = null;

    if (!itemRef.id) {
        return {
            isEnd: true,
            sheetItem: normalizedPage === 1 ? mappedSheetItem || sourceItem : sourceItem,
            musicList: [],
        };
    }

    endpointBase =
        itemRef.kind === "toplist"
            ? "/mf/v1/toplists/" + itemRef.id
            : "/mf/v1/playlists/" + itemRef.id;

    try {
        if (normalizedPage === 1) {
            try {
                detail = await requestGet(endpointBase);
                mappedSheetItem = mapSheetItem(detail) || mappedSheetItem;
            } catch (_error) {
                detail = null;
            }
        }

        tracksPayload = await requestGet(endpointBase + "/tracks", {
            page: normalizedPage,
            page_size: LIST_PAGE_SIZE,
        });
        rawList = extractList(tracksPayload);
        for (i = 0; i < rawList.length; i += 1) {
            mapped = mapMusicItem(rawList[i]);
            if (mapped) {
                musicList.push(mapped);
            }
        }

        result = {
            isEnd: resolveIsEnd(
                tracksPayload,
                normalizedPage,
                LIST_PAGE_SIZE,
                rawList.length,
            ),
            musicList: musicList,
        };
        if (normalizedPage === 1) {
            result.sheetItem =
                mappedSheetItem ||
                mapSheetItem(sourceItem) || {
                    id: toTrimmedString(sourceItem.id || itemRef.id),
                };
        }
        return result;
    } catch (_error2) {
        result = {
            isEnd: true,
            musicList: [],
        };
        if (normalizedPage === 1) {
            result.sheetItem =
                mappedSheetItem ||
                mapSheetItem(sourceItem) || {
                    id: toTrimmedString(sourceItem.id || itemRef.id),
                };
        }
        return result;
    }
}

async function getArtistWorks(artistItem, page, type) {
    var normalizedPage = toPositivePage(page);
    var itemRef = parsePublicItemRef(artistItem && artistItem.id);
    var payload = null;
    var rawList = [];
    var data = [];
    var i = 0;
    var mapped = null;

    if (type !== "music" || itemRef.kind !== "artist" || !itemRef.id) {
        return { isEnd: true, data: [] };
    }

    try {
        payload = await requestGet("/mf/v1/artists/" + itemRef.id + "/tracks", {
            page: normalizedPage,
            page_size: LIST_PAGE_SIZE,
        });
        rawList = extractList(payload);
        for (i = 0; i < rawList.length; i += 1) {
            mapped = mapMusicItem(rawList[i]);
            if (mapped) {
                data.push(mapped);
            }
        }
        return {
            isEnd: resolveIsEnd(payload, normalizedPage, LIST_PAGE_SIZE, rawList.length),
            data: data,
        };
    } catch (_error) {
        return { isEnd: true, data: [] };
    }
}

async function getTopLists() {
    try {
        var payload = await requestGet("/mf/v1/toplists");
        return normalizeTopListGroups(payload);
    } catch (_error) {
        return [];
    }
}

async function getTopListDetail(topListItem, page) {
    var normalizedPage = toPositivePage(page);
    var sourceItem = topListItem && typeof topListItem === "object" ? topListItem : {};
    var toplistId = parsePublicId(sourceItem.id);
    var mappedTopListItem = mapSheetItem(sourceItem);
    var detail = null;
    var tracksPayload = null;
    var rawList = [];
    var musicList = [];
    var i = 0;
    var mapped = null;
    var result = null;

    if (!toplistId) {
        return {
            isEnd: true,
            topListItem: normalizedPage === 1 ? mappedTopListItem || sourceItem : sourceItem,
            musicList: [],
        };
    }

    try {
        if (normalizedPage === 1) {
            try {
                detail = await requestGet("/mf/v1/toplists/" + toplistId);
                mappedTopListItem = mapSheetItem(detail) || mappedTopListItem;
            } catch (_error) {
                detail = null;
            }
        }

        tracksPayload = await requestGet("/mf/v1/toplists/" + toplistId + "/tracks", {
            page: normalizedPage,
            page_size: LIST_PAGE_SIZE,
        });
        rawList = extractList(tracksPayload);
        for (i = 0; i < rawList.length; i += 1) {
            mapped = mapMusicItem(rawList[i]);
            if (mapped) {
                musicList.push(mapped);
            }
        }

        result = {
            isEnd: resolveIsEnd(
                tracksPayload,
                normalizedPage,
                LIST_PAGE_SIZE,
                rawList.length,
            ),
            topListItem:
                normalizedPage === 1
                    ? mappedTopListItem ||
                      mapSheetItem(sourceItem) || {
                          id: toTrimmedString(sourceItem.id || toplistId),
                      }
                    : sourceItem || {
                          id: toTrimmedString(sourceItem.id || toplistId),
                      },
            musicList: musicList,
        };
        return result;
    } catch (_error2) {
        result = {
            isEnd: true,
            musicList: [],
        };
        if (normalizedPage === 1) {
            result.topListItem =
                mappedTopListItem ||
                mapSheetItem(sourceItem) || {
                    id: toTrimmedString(sourceItem.id || toplistId),
                };
        }
        return result;
    }
}

module.exports = {
    platform: "Music_Server_LAN",
    version: "17011.0.1",
    author: "Codex",
    srcUrl: "__MUSIC_SERVER_PLUGIN_SRC_URL__",
    cacheControl: "no-cache",
    primaryKey: ["id"],
    description: "Music_Server LAN-first plugin for playlists, toplists, search, playback, and token status.",
    supportedSearchType: ["music", "artist", "sheet"],
    userVariables: [
        { key: "baseUrl", name: "Base URL" },
        { key: "lanBaseUrl", name: "LAN Base URL" },
        { key: "accessToken", name: "Access Token" },
    ],
    normalizeBaseUrl: normalizeBaseUrl,
    readConfigValue: readConfigValue,
    readRuntimeValue: readRuntimeValue,
    createDefaultClient: createDefaultClient,
    getClient: getClient,
    search: search,
    getArtistWorks: getArtistWorks,
    getMediaSource: getMediaSource,
    getRecommendSheetTags: getRecommendSheetTags,
    getRecommendSheetsByTag: getRecommendSheetsByTag,
    getMusicSheetInfo: getMusicSheetInfo,
    getTopLists: getTopLists,
    getTopListDetail: getTopListDetail,
    getPluginStatus: getPluginStatus,
    __setHttpClientForTests: __setHttpClientForTests,
    __setConfigForTests: __setConfigForTests,
    __clearTestState: __clearTestState,
};