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) =>
	(title || '')
		.toLowerCase()
		.replace(/\b(s|season|part|cour)\s*\d+/g, '')
		.replace(/[\W_]+/g, ' ')
		.trim();

const findClosestMatch = (times: Time[], titles: string[]): Time | null => {
	let bestMatch: Time | null = null;
	let highestScore = 0;

	times.forEach((time) => {
		titles.map(normalizeTitle).forEach((title) => {
			const similarityScore = stringSimilarity.compareTwoStrings(normalizeTitle(time.title), title);

			if (similarityScore > highestScore) {
				highestScore = similarityScore;
				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;
};