import rawLieux from './data/lieux.json';
import rawStreet from './data/street.json';
import type {
	Categorie,
	Difficulte,
	ExplorerLieu,
	GuessResult,
	Lieu,
	Region,
	RoundPlace,
	StreetLieu
} from '$lib/types';

const lieux = rawLieux as Lieu[];
const street = rawStreet as StreetLieu[];

/** Lieu « scorable » : les deux corpus partagent les champs du scoring. */
type Scoreable = Lieu | StreetLieu;

const REGIONS: Region[] = ['GUADELOUPE', 'MARTINIQUE', 'GUYANE', 'REUNION'];
const CATEGORIES: Categorie[] = ['MONUMENT', 'LIEU'];

export const MAX_POINTS = 5000;

/** Rayon (km) de la courbe de score selon la difficulté du lieu. */
export const RAYONS: Record<Difficulte, number> = {
	FACILE: 50,
	MOYEN: 15,
	DIFFICILE: 5,
	EXPERT: 1
};

/** Distance haversine en km. */
export function haversineKm(a: { lat: number; lon: number }, b: { lat: number; lon: number }): number {
	const R = 6371;
	const dLat = ((b.lat - a.lat) * Math.PI) / 180;
	const dLon = ((b.lon - a.lon) * Math.PI) / 180;
	const s =
		Math.sin(dLat / 2) ** 2 +
		Math.cos((a.lat * Math.PI) / 180) * Math.cos((b.lat * Math.PI) / 180) * Math.sin(dLon / 2) ** 2;
	return 2 * R * Math.asin(Math.sqrt(s));
}

function parseRegion(value: string | null): Region | null {
	return value && REGIONS.includes(value as Region) ? (value as Region) : null;
}

function parseCategorie(value: string | null): Categorie | null {
	return value && CATEGORIES.includes(value as Categorie) ? (value as Categorie) : null;
}

/** Recherche dans les deux corpus (photos classiques + street Mapillary). */
export function getLieuById(id: string): Scoreable | undefined {
	return lieux.find((l) => l.id === id) ?? street.find((l) => l.id === id);
}

/** Recherche limitée au corpus photo classique (défi, proxy photo). */
export function getLieuPhotoById(id: string): Lieu | undefined {
	return lieux.find((l) => l.id === id);
}

/** Sélection aléatoire d'un lieu, avec filtres optionnels. */
export function getRandomLieu(options: {
	region?: string | null;
	categorie?: string | null;
	exclude?: string | null;
}): Lieu | null {
	const region = parseRegion(options.region ?? null);
	const categorie = parseCategorie(options.categorie ?? null);
	const excluded = new Set(
		(options.exclude ?? '')
			.split(',')
			.map((s) => s.trim())
			.filter(Boolean)
	);
	let pool = lieux.filter((l) => !excluded.has(l.id));
	if (region) pool = pool.filter((l) => l.region === region);
	if (categorie) pool = pool.filter((l) => l.categorie === categorie);
	// Si tout a été exclu, on réessaie sans les exclusions (le jeu doit continuer).
	if (pool.length === 0) {
		pool = lieux;
		if (region) pool = pool.filter((l) => l.region === region);
		if (categorie) pool = pool.filter((l) => l.categorie === categorie);
	}
	if (pool.length === 0) return null;
	return pool[Math.floor(Math.random() * pool.length)];
}

/** Sélection aléatoire d'un lieu street (mode « An lari a », corpus Mapillary). */
export function getRandomStreet(options: {
	region?: string | null;
	exclude?: string | null;
}): StreetLieu | null {
	const region = parseRegion(options.region ?? null);
	const excluded = new Set(
		(options.exclude ?? '')
			.split(',')
			.map((s) => s.trim())
			.filter(Boolean)
	);
	let pool = street.filter((l) => !excluded.has(l.id));
	if (region) pool = pool.filter((l) => l.region === region);
	// Si tout a été exclu, on réessaie sans les exclusions (le jeu doit continuer).
	if (pool.length === 0) {
		pool = region ? street.filter((l) => l.region === region) : street;
	}
	if (pool.length === 0) return null;
	return pool[Math.floor(Math.random() * pool.length)];
}

/** Largeurs (px) servies par le proxy photo /api/photo/[id]?w=. */
export const PHOTO_LARGEURS = [400, 800, 1200] as const;

/**
 * Anti-triche : ne garde que les champs publiques pour /api/round.
 * L'URL photo passe par le proxy serveur (/api/photo/<uuid>) : l'URL Wikimedia
 * Commons d'origine contient le nom du fichier, qui révèle souvent le lieu (C4).
 */
export function sanitizeRound(lieu: Lieu): RoundPlace {
	return {
		id: lieu.id,
		nom: lieu.nom,
		nom_creole: lieu.nom_creole,
		categorie: lieu.categorie,
		difficulte: lieu.difficulte,
		photo: {
			url: `/api/photo/${lieu.id}`,
			srcset: {
				'400': `/api/photo/${lieu.id}?w=400`,
				'800': `/api/photo/${lieu.id}?w=800`,
				'1200': `/api/photo/${lieu.id}?w=1200`
			},
			credit: lieu.photo.credit,
			alt: lieu.photo.alt
		},
		indices: lieu.indices
	};
}

/**
 * Anti-triche, mode street : ne garde que les champs publics.
 * Seul `mapillaryId` part au client (la visionneuse doit bien appeler Mapillary) ;
 * coords/commune/région/wikidata_id ne partent jamais avant le guess.
 * Limitation documentée (architecture.md §10) : l'image_key est publique côté
 * Mapillary, un joueur techniquement équipé peut retrouver la position — même
 * propriété que GeoGuessr/Street View, acceptable en solo sans leaderboard.
 */
export function sanitizeRoundStreet(lieu: StreetLieu): RoundPlace {
	return {
		id: lieu.id,
		nom: lieu.nom,
		nom_creole: lieu.nom_creole,
		categorie: 'LIEU',
		difficulte: lieu.difficulte,
		mapillaryId: lieu.mapillary_id,
		credit: `© ${lieu.credit.username} / Mapillary (CC BY-SA 4.0)`,
		indices: lieu.indices
	};
}

/**
 * Rayon effectif (km) de la courbe de score (audit A1).
 * Les communes guyanaises sont immenses (Saint-Laurent-du-Maroni ≈ 4 321 km²) :
 * avec le seul rayon de difficulté, un guess à quelques dizaines de km y est
 * injustement quasi nul. Quand `aire_commune_km2` est renseigné, le rayon est
 * au moins celui du disque de même aire que la commune : sqrt(aire / π).
 * Champ optionnel : sans lui, on retombe sur le rayon de difficulté.
 */
export function rayonEffectifKm(lieu: Scoreable): number {
	const base = RAYONS[lieu.difficulte];
	const aire = lieu.aire_commune_km2;
	if (typeof aire === 'number' && Number.isFinite(aire) && aire > 0) {
		return Math.max(base, Math.sqrt(aire / Math.PI));
	}
	return base;
}

/**
 * Scoring recalculé côté serveur :
 * score = round(5000 × e^(−d/r_eff)) ; pénalité −10 % par indice ;
 * bonus temps ≤ +20 % ; total plafonné à 5000.
 */
export function scoreGuess(
	lieu: Scoreable,
	guess: { lat: number; lon: number },
	hintsUsed: number,
	timeMs?: number
): GuessResult {
	const distanceKm = haversineKm(guess, lieu.coordonnees);
	const radiusEff = rayonEffectifKm(lieu);
	const base = Math.round(MAX_POINTS * Math.exp(-distanceKm / radiusEff));
	const penalises = base * Math.max(0, 1 - 0.1 * Math.max(0, hintsUsed));
	let total = penalises;
	if (typeof timeMs === 'number' && Number.isFinite(timeMs) && timeMs >= 0) {
		total += penalises * 0.2 * Math.max(0, 1 - timeMs / 60000);
	}
	const score = Math.min(MAX_POINTS, Math.round(total));
	return {
		distanceKm: Math.round(distanceKm * 10) / 10,
		score,
		radiusEffKm: Math.round(radiusEff * 10) / 10,
		coordonnees: lieu.coordonnees,
		commune: lieu.commune,
		region: lieu.region,
		nom: lieu.nom,
		nom_creole: lieu.nom_creole,
		wikidata_id: lieu.wikidata_id
	};
}

/** Réponse « Passer » : la vérité est révélée, score 0, pas de distance. */
export function skipResult(lieu: Scoreable): GuessResult {
	return {
		distanceKm: null,
		score: 0,
		radiusEffKm: null,
		coordonnees: lieu.coordonnees,
		commune: lieu.commune,
		region: lieu.region,
		nom: lieu.nom,
		nom_creole: lieu.nom_creole,
		wikidata_id: lieu.wikidata_id
	};
}

/**
 * Catalogue Explorer : coords arrondies à 0.05° (mode sans score, fiches autorisées).
 * L'`id` (uuid) n'est volontairement PAS exposé : il permettrait de corréler
 * l'id d'un round avec la commune du lieu (fuite de réponse, audit C4).
 * L'Explorer n'a pas besoin d'ids stables (le front utilise l'indice du tableau).
 */
export function catalogueExplorer(): ExplorerLieu[] {
	return lieux.map((l) => ({
		nom: l.nom,
		nom_creole: l.nom_creole,
		region: l.region,
		commune: l.commune,
		coordonnees: {
			lat: Math.round(l.coordonnees.lat / 0.05) * 0.05,
			lon: Math.round(l.coordonnees.lon / 0.05) * 0.05
		},
		categorie: l.categorie,
		difficulte: l.difficulte,
		wikidata_id: l.wikidata_id,
		photo: l.photo
	}));
}