import {
  MWMediaProvider,
  MWMediaType,
  MWPortableMedia,
  MWMediaStream,
  MWQuery,
  MWProviderMediaResult,
  MWMediaCaption
} from "providers/types";

import { CORS_PROXY_URL } from "mw_constants";

export const xemovieScraper: MWMediaProvider = {
  id: "xemovie",
  enabled: false,
  type: [MWMediaType.MOVIE],
  displayName: "xemovie",

  async getMediaFromPortable(media: MWPortableMedia): Promise<MWProviderMediaResult> {
    const res = await fetch(
      `${CORS_PROXY_URL}https://xemovie.co/movies/${media.mediaId}/watch`,
    ).then(d => d.text());

    const DOM = new DOMParser().parseFromString(res, "text/html");

    const title = DOM.querySelector(".text-primary.text-lg.font-extrabold")?.textContent || "";
    const year = DOM.querySelector("div.justify-between:nth-child(3) > div:nth-child(2)")?.textContent || "";

    return {
      ...media,
      title,
      year,
    } as MWProviderMediaResult;
  },

  async searchForMedia(query: MWQuery): Promise<MWProviderMediaResult[]> {
    const term = query.searchQuery.toLowerCase();

    const searchUrl = `${CORS_PROXY_URL}https://xemovie.co/search?q=${encodeURIComponent(term)}`;
    const searchRes = await fetch(searchUrl).then((d) => d.text());

    const parser = new DOMParser();
    const doc = parser.parseFromString(searchRes, "text/html");

    const movieContainer = doc.querySelectorAll(".py-10")[0].querySelector(".grid");
    if (!movieContainer) return [];
    const movieNodes = Array.from(movieContainer.querySelectorAll("a")).filter(link => !link.className);

    const results: MWProviderMediaResult[] = movieNodes.map((node) => {
      const parent = node.parentElement;
      if (!parent) return;

      const aElement = parent.querySelector("a");
      if (!aElement) return;

      return {
        title: parent.querySelector("div > div > a > h6")?.textContent,
        year: parent.querySelector("div.float-right")?.textContent,
        mediaId: aElement.href.split('/').pop() || "",
      }
    }).filter((d): d is MWProviderMediaResult => !!d);

    return results;
  },

  async getStream(media: MWPortableMedia): Promise<MWMediaStream> {
    if (media.mediaType !== MWMediaType.MOVIE) throw new Error("Incorrect type")

    const url = `${CORS_PROXY_URL}https://xemovie.co/movies/${media.mediaId}/watch`;

    let streamUrl = "";
    const subtitles: MWMediaCaption[] = [];

    const res = await fetch(url).then(d => d.text());
    const scripts = Array.from(new DOMParser().parseFromString(res, "text/html").querySelectorAll("script"));

    for (const script of scripts) {
      if (!script.textContent) continue;

      if (script.textContent.match(/https:\/\/[a-z][0-9]\.xemovie\.com/)) {
        const data = JSON.parse(JSON.stringify(eval(`(${script.textContent.replace("const data = ", "").split("};")[0]}})`)));
        streamUrl = data.playlist[0].file;

        for (const [index, subtitleTrack] of data.playlist[0].tracks.entries()) {
          const subtitleBlob = URL.createObjectURL(
            await fetch(`${CORS_PROXY_URL}${subtitleTrack.file}`).then((captionRes) => captionRes.blob())
          ); // do this so no need for CORS errors

          subtitles.push({
            id: index,
            url: subtitleBlob,
            label: subtitleTrack.label
          })
        }
      }
    }

    const streamType = streamUrl.split('.').at(-1);
    if (streamType !== "mp4" && streamType !== "m3u8") throw new Error("Unsupported stream type");

    return { url: streamUrl, type: streamType, captions: subtitles } as MWMediaStream;
  }
};