import { recentMediaActivities, type Media } from '$lib/Data/AniList/media';
import { getChapterCount } from '$lib/Data/Manga/raw';
import proxy from '$lib/Utility/proxy';
import settings from '$stores/settings';
import type { UserIdentity } from '../../Data/AniList/identity';
import { database } from '../../Database/IDB/chapters';

const getManga = async (
  statusIn: string,
  year: number,
  native: string | null,
  english: string | null,
  romaji: string | null
) => {
  let status = '';
  let error = false;

  switch (statusIn) {
    case 'FINISHED':
      {
        status = 'completed';
      }
      break;
    case 'RELEASING':
      {
        status = 'ongoing';
      }
      break;
    case 'HIATUS':
      {
        status = 'hiatus';
      }
      break;
    case 'CANCELLED':
      {
        status = 'cancelled';
      }
      break;
  }

  const nullIfNullString = (s: string | null) => (s == 'null' ? null : s);
  const get = async (title: string) => {
    try {
      return await (
        await fetch(
          proxy(
            `https://api.mangadex.org/manga?title=${encodeURIComponent(
              title
            )}&year=${year}&status[]=${status}`
          )
        )
      ).json();
    } catch {
      error = true;
    }
  };

  let mangadexData = await get(
    nullIfNullString(native) || nullIfNullString(english) || nullIfNullString(romaji) || ''
  );

  if (error) return new Response('rate-limited');

  if (mangadexData['data'] === undefined || mangadexData['data'].length === 0) {
    mangadexData = await get(nullIfNullString(english) || '');

    if (mangadexData['data'] === undefined || mangadexData['data'].length === 0) {
      mangadexData = await get(nullIfNullString(romaji) || '');
    }
  }

  return Response.json(mangadexData, {
    headers: {
      'Cache-Control': 'max-age=300'
    }
  });
};

export const chapterCount = async (
  identity: UserIdentity,
  manga: Media,
  disableGuessing: boolean
  // preferActivity = false
): Promise<number | null> => {
  const chapters = await database.chapters.get(manga.id);

  if (chapters !== undefined) return chapters.chapters === -1 ? null : chapters.chapters;

  // if (preferActivity) {
  // 	return await recentMediaActivities(identity, manga);
  // }

  const tryRecentMediaActivities = async () => {
    if (disableGuessing) {
      await database.chapters.put({
        id: manga.id,
        chapters: -1,
        volumes: null
      });

      return null;
    }

    const anilistData = await recentMediaActivities(
      identity,
      manga,
      settings.get().calculateGuessMethod
    );

    await database.chapters.put({
      id: manga.id,
      chapters: anilistData ? anilistData : -1,
      volumes: null
    });

    return anilistData;
  };

  if (manga.format === 'NOVEL') return await tryRecentMediaActivities();

  let lastChapter = 0;
  let completedVolumes = null;

  if (!settings.get().calculatePreferNativeChapterCount) {
    const mangadexData = await getManga(
      manga.status,
      manga.startDate.year,
      manga.title.native,
      manga.title.english,
      manga.title.romaji
    );

    if ((await mangadexData.clone().text()) === 'rate-limited') return -22;

    const mangadexDataJson = await mangadexData.json();

    if (mangadexDataJson['data'] === undefined || mangadexDataJson['data'].length === 0)
      return await tryRecentMediaActivities();

    const mangadexId = mangadexDataJson['data'][0]['id'];
    const lastChapterDataJson = await (
      await fetch(
        proxy(
          `https://api.mangadex.org/manga/${mangadexId}/feed?order[chapter]=desc&translatedLanguage[]=en&limit=1&contentRating[]=safe&contentRating[]=suggestive&contentRating[]=erotica&contentRating[]=pornographic`
        )
      )
    ).json();

    if (lastChapterDataJson['data'] === undefined || lastChapterDataJson['data'].length === 0)
      return await tryRecentMediaActivities();

    lastChapter = lastChapterDataJson['data'][0]['attributes']['chapter'];
    completedVolumes = null;

    if ((manga.mediaListEntry || { progress: 0 }).progress > lastChapter && !disableGuessing) {
      const anilistData = await recentMediaActivities(
        identity,
        manga,
        settings.get().calculateGuessMethod
      );

      if (anilistData !== null && anilistData > lastChapter) lastChapter = anilistData;
    }

    if (!settings.get().calculateDisableOutOfDateVolumeWarning) {
      const volumeOfChapterData = await (
        await fetch(
          proxy(
            `https://api.mangadex.org/chapter?manga=${mangadexId}&chapter=${manga.mediaListEntry?.progress}&contentRating[]=safe&contentRating[]=suggestive&contentRating[]=erotica&contentRating[]=pornographic&limit=1`
          )
        )
      ).json();
      let lastAvailableVolume = lastChapterDataJson['data'][0]['attributes']['volume'];

      if (lastAvailableVolume === null) {
        let chapterIndex = 0;

        while (chapterIndex < lastChapterDataJson['data'].length && lastAvailableVolume === null) {
          if (lastChapterDataJson['data'][chapterIndex]['attributes']['volume'] !== null)
            lastAvailableVolume = lastChapterDataJson['data'][chapterIndex]['attributes']['volume'];

          chapterIndex += 1;
        }
      }

      if (volumeOfChapterData['data'] !== undefined && volumeOfChapterData['data'].length > 0) {
        const volumeOfChapter = volumeOfChapterData['data'][0]['attributes']['volume'];

        if (volumeOfChapter !== null) completedVolumes = volumeOfChapter;

        if (completedVolumes === volumeOfChapter) completedVolumes -= 1;
      }
    }
  } else {
    lastChapter = (await getChapterCount(manga.title.native)) || 0;
  }

  if (lastChapter == 0) lastChapter = -1;

  await database.chapters.put({
    id: manga.id,
    chapters: Number(lastChapter),
    volumes: completedVolumes
  });

  return Number(lastChapter);
};