import { get } from 'svelte/store';
import type { Media } from '../../../../AniList/media';
import settings from '$stores/settings';
import type { SubsPlease } from '$lib/Media/Anime/Airing/Subtitled/subsPlease';
import stringSimilarity from 'string-similarity';

export interface Time {
	title: string;
	time: string;
	day: string;
}

const secondsUntil = (targetTime: string, targetDay: string) => {
	const now = new Date();
	const [targetHour, targetMinute] = targetTime.split(':').map(Number);
	let dayDifference =
		['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'].indexOf(
			targetDay
		) - now.getDay();

	if (dayDifference < 0) dayDifference += 7;

	const targetDate = new Date(now);

	targetDate.setDate(now.getDate() + dayDifference);
	targetDate.setHours(targetHour, targetMinute, 0, 0);

	const secondsDifference = (Number(targetDate) - Number(now)) / 1000;

	return secondsDifference > 0 ? secondsDifference : secondsDifference + 7 * 24 * 60 * 60;
};

const normalizeTitle = (title: string | null) => {
	return (title || '')
		.toLowerCase()
		.replace(/season \d+|s\d+/g, '')
		.replace(/\b(\d)(st|nd|rd|th)\b/g, '$1')
		.replace(/\b(part|pt)\b/gi, '')
		.trim();
};

const findClosestMatch = (times: Time[], titles: string[]) => {
	const normalizedTitles = titles
		.map((title) => title?.toLowerCase().trim())
		.filter((title) => title);
	const timesWithNormalizedTitles = times
		.filter((time) => time.title !== null && time.title.trim() !== '')
		.map((time) => ({ ...time, title: (time.title as string).toLowerCase().trim() }));

	for (const time of timesWithNormalizedTitles)
		if (normalizedTitles.includes(time.title)) return time;

	let bestMatch = null;
	let highestMatchScore = 0;

	for (const time of timesWithNormalizedTitles)
		for (const title of normalizedTitles)
			if (time.title.includes(title) || title.includes(time.title)) {
				const matchScore = Math.min(title.length, time.title.length);

				if (matchScore > highestMatchScore) {
					highestMatchScore = matchScore;
					bestMatch = time;
				}
			}

	return bestMatch;
};

export const findClosestMedia = (media: Media[], matchFor: string) => {
	if (!matchFor) return null;

	let bestFitMedia: Media | null = null;
	let smallestDistance = -Infinity;

	media.forEach((m) => {
		const titles = [m.title.romaji, m.title.english, ...m.synonyms].filter(Boolean);

		titles.forEach((title) => {
			const normalisedTitle = normalizeTitle(title);
			const normalisedMatchFor = normalizeTitle(matchFor);
			const distance = stringSimilarity.compareTwoStrings(normalisedMatchFor, normalisedTitle);

			if (
				distance > smallestDistance &&
				(normalisedMatchFor
					.split(' ')
					.filter((word) => titles.some((title) => normalizeTitle(title).includes(word))).length >=
					normalisedMatchFor.split(' ').length ||
					titles.some((title) => normalizeTitle(title).includes(normalisedMatchFor)))
			) {
				smallestDistance = distance;
				bestFitMedia = m;
			}
		});
	});

	return bestFitMedia as Media | null;
};

export const injectAiringTime = (anime: Media, subsPlease: SubsPlease | null) => {
	const airingAt = anime.nextAiringEpisode?.airingAt;
	// const nativeUntilAiring = airingAt
	// 	? Math.round((airingAt - Date.now() / 1000) * 100) / 100
	// 	: undefined;
	const nativeTime = new Date(airingAt ? airingAt * 1000 : 0);
	let untilAiring;
	let time = new Date(airingAt ? airingAt * 1000 : 0);
	let nextEpisode = anime.nextAiringEpisode?.episode || 0;

	if (
		!(
			(get(settings).displayNativeCountdown || !subsPlease)
			// || !(nativeUntilAiring !== undefined && nativeUntilAiring < 24 * 60 * 60)
		)
	) {
		const times: Time[] = [];

		for (const [key, value] of Object.entries(subsPlease.schedule)) {
			const flattenedValue = Array.isArray(value) ? value.flat() : [];

			for (const time of flattenedValue) {
				times.push({
					title: time.title,
					time: time.time,
					day: key
				});
			}
		}

		const foundTime: Time | null = findClosestMatch(times, [
			anime.title.romaji,
			anime.title.english,
			...anime.synonyms
		]);

		if (foundTime) {
			untilAiring = secondsUntil((foundTime as Time).time, (foundTime as Time).day);
			time = new Date(Date.now() + untilAiring * 1000);
		}
	}

	if (
		airingAt &&
		nativeTime.getTime() !== time.getTime() &&
		nativeTime.getTime() - time.getTime() > 24 * 60 * 60 * 1000
	)
		nextEpisode -= 1;

	return {
		...anime,
		nextAiringEpisode: {
			episode: nextEpisode,
			airingAt: time.getTime() / 1000,
			nativeAiringAt: nativeTime.getTime() / 1000
		}
	} as Media;
};