import { recentMediaActivities, type Media } from '$lib/AniList/media';
import settings from '../../../stores/settings';
import type { UserIdentity } from '../../AniList/identity';
import { database } from '../../Database/chapters';

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) 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();

	const mangadexData = await fetch(
		`/api/mangadex/manga?english=${manga.title.english}&year=${manga.startDate.year}&romaji=${manga.title.romaji}&native=${manga.title.native}&status=${manga.status}`
	);

	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 lastChapterData = await fetch(`/api/mangadex/feed?id=${mangadexId}`);

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

	const lastChapterDataJson = await lastChapterData.json();

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

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

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

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

	if (!settings.get().calculateDisableOutOfDateVolumeWarning) {
		const volumeOfChapterDataResponse = await fetch(
			`/api/mangadex/chapter?id=${mangadexId}&chapter=${manga.mediaListEntry?.progress}`
		);

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

		const volumeOfChapterData = await volumeOfChapterDataResponse.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;
		}
	}

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

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

	return Number(lastChapter);
};