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 preprocessTitle = (title: string): string => {
	return title
		.toLowerCase()
		.replace(/\b(season|s|part|cour)\b/g, ' ')
		.replace(/[^a-z0-9\s]/gi, '')
		.trim()
		.split(/\s+/)
		.join(' ');
};

const calculateWeightedSimilarity = (title1: string, title2: string): number => {
	const tokens1 = title1.split(' ');
	const tokens2 = title2.split(' ');
	const set2 = new Set(tokens2);
	let score = 0;

	tokens1.forEach((token) => {
		if (set2.has(token)) {
			score += /^\d+$/.test(token) ? 2 : 1;
		}
	});

	return score / (Math.max(tokens1.length, tokens2.length) * 2);
};

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

	titles.filter(Boolean).forEach((searchTitle) => {
		if (searchTitle.includes('OVA') || searchTitle.includes('Special')) return;

		const normalizedSearchTitle = preprocessTitle(searchTitle);

		times.forEach((time) => {
			const normalizedTimeTitle = preprocessTitle(time.title);
			const similarityScore = calculateWeightedSimilarity(
				normalizedSearchTitle,
				normalizedTimeTitle
			);

			if (similarityScore > bestScore) {
				bestScore = similarityScore;
				bestMatch = time;
			}
		});
	});

	return bestMatch;
};

const normalizeTitle = (title: string | null) =>
	(title || '')
		.toLowerCase()
		.replace(/\b(s|season|part|cour)\s*\d+/g, '')
		.replace(/[\W_]+/g, ' ')
		.trim();

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

		if (
			titles.some(
				(title) => title.toLowerCase().includes('special') || title.toLowerCase().includes('ova')
			)
		)
			return;

		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;
};