package services

import (
	"math"
	"testing"
)

// Repères réels de Nantes (44000) utilisés pour vérifier le calcul de
// distance/temps de trajet des commandes.
var (
	placeRoyale    = Coordinates{Latitude: 47.2148, Longitude: -1.5584}
	gareNantes     = Coordinates{Latitude: 47.2173, Longitude: -1.5426}
	aeroportNantes = Coordinates{Latitude: 47.1532, Longitude: -1.6107}
)

func almostEqual(a, b, tolerance float64) bool {
	return math.Abs(a-b) <= tolerance
}

func TestCalculateDistance_SamePointIsZero(t *testing.T) {
	if got := CalculateDistance(placeRoyale, placeRoyale); got != 0 {
		t.Errorf("distance entre un point et lui-même: got=%.4f want=0", got)
	}
}

// Le long d'un même méridien (même longitude), la distance Haversine est
// exacte : 1° de latitude = R * (π/180) ≈ 111.19 km.
func TestCalculateDistance_OneDegreeLatitudeIsExact(t *testing.T) {
	from := Coordinates{Latitude: 47.0, Longitude: -1.5536}
	to := Coordinates{Latitude: 48.0, Longitude: -1.5536}
	want := EarthRadiusKm * (math.Pi / 180.0)

	got := CalculateDistance(from, to)
	if !almostEqual(got, want, 0.01) {
		t.Errorf("distance 1° de latitude: got=%.4f want=%.4f", got, want)
	}
}

func TestCalculateDistance_IsSymmetric(t *testing.T) {
	d1 := CalculateDistance(placeRoyale, gareNantes)
	d2 := CalculateDistance(gareNantes, placeRoyale)
	if !almostEqual(d1, d2, 0.0001) {
		t.Errorf("la distance doit être symétrique: A->B=%.4f B->A=%.4f", d1, d2)
	}
}

// Place Royale <-> Aéroport de Nantes : environ 8 km à vol d'oiseau.
func TestCalculateDistance_RealNantesLandmarks(t *testing.T) {
	got := CalculateDistance(placeRoyale, aeroportNantes)
	if got < 6 || got > 10 {
		t.Errorf("distance Place Royale -> Aéroport Nantes hors plage réaliste: got=%.2f km, want=[6,10]", got)
	}
}

func TestCalculateETA_VeryCloseReturnsMinETA(t *testing.T) {
	cases := []float64{0, 0.01, 0.05, 0.099}
	for _, d := range cases {
		if got := CalculateETA(d); got != MinETA {
			t.Errorf("CalculateETA(%.3f km): got=%d want=%d (MinETA)", d, got, MinETA)
		}
	}
}

// Formule : (distance/25 km/h)*60 min, +20% de marge trafic, arrondi par troncature.
func TestCalculateETA_MatchesFormulaForNormalDistance(t *testing.T) {
	distanceKm := 10.0
	travelTime := (distanceKm / 25.0) * 60.0
	want := int(travelTime * 1.2)

	got := CalculateETA(distanceKm)
	if got != want {
		t.Errorf("CalculateETA(%.1f km): got=%d want=%d", distanceKm, got, want)
	}
}

func TestCalculateETA_VeryFarClampsToMaxETA(t *testing.T) {
	if got := CalculateETA(1000); got != MaxETA {
		t.Errorf("CalculateETA(1000 km): got=%d want=%d (MaxETA)", got, MaxETA)
	}
}

// L'ETA ne doit jamais sortir de l'intervalle [MinETA, MaxETA], quelle que
// soit la distance fournie (y compris des valeurs aberrantes).
func TestCalculateETA_AlwaysWithinBounds(t *testing.T) {
	distances := []float64{-5, 0, 0.05, 1, 5, 10, 50, 100, 500, 10000}
	for _, d := range distances {
		got := CalculateETA(d)
		if got < MinETA || got > MaxETA {
			t.Errorf("CalculateETA(%.2f): got=%d, hors bornes [%d,%d]", d, got, MinETA, MaxETA)
		}
	}
}

// Sans clé TomTom configurée (cas de cet environnement de test), le calcul
// doit retomber sur Haversine + CalculateETA, sans appel réseau.
func TestCalculateETAWithTomTom_FallsBackToHaversineWithoutAPIKey(t *testing.T) {
	if len(tomTomKeys.keys) != 0 {
		t.Skip("test valable uniquement sans clé TomTom configurée dans l'environnement")
	}

	wantDistance := CalculateDistance(placeRoyale, aeroportNantes)
	wantETA := CalculateETA(wantDistance)

	gotETA, gotDistance, err := CalculateETAWithTomTom(placeRoyale, aeroportNantes)
	if err != nil {
		t.Fatalf("CalculateETAWithTomTom (fallback): %v", err)
	}
	if gotDistance != wantDistance {
		t.Errorf("distance fallback: got=%.4f want=%.4f", gotDistance, wantDistance)
	}
	if gotETA != wantETA {
		t.Errorf("ETA fallback: got=%d want=%d", gotETA, wantETA)
	}
}

func TestValidateCoordinates(t *testing.T) {
	cases := []struct {
		name    string
		coords  Coordinates
		wantErr bool
	}{
		{"Nantes valide", placeRoyale, false},
		{"latitude limite haute valide", Coordinates{Latitude: 90, Longitude: 0}, false},
		{"latitude limite basse valide", Coordinates{Latitude: -90, Longitude: 0}, false},
		{"latitude trop haute", Coordinates{Latitude: 90.1, Longitude: 0}, true},
		{"latitude trop basse", Coordinates{Latitude: -90.1, Longitude: 0}, true},
		{"longitude limite haute valide", Coordinates{Latitude: 0, Longitude: 180}, false},
		{"longitude trop haute", Coordinates{Latitude: 0, Longitude: 180.1}, true},
		{"longitude trop basse", Coordinates{Latitude: 0, Longitude: -180.1}, true},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			err := ValidateCoordinates(c.coords)
			if c.wantErr && err == nil {
				t.Error("attendu une erreur, reçu nil")
			}
			if !c.wantErr && err != nil {
				t.Errorf("erreur inattendue: %v", err)
			}
		})
	}
}