package official_climb_test

import (
	"testing"
	"time"

	"github.com/jftuga/geodist"
	"github.com/martinlehoux/biking_home/internal/dbtest"
	"github.com/martinlehoux/biking_home/official_climb"
	"github.com/martinlehoux/biking_home/ride"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestCreateListAndGetOfficialClimb(t *testing.T) {
	db := dbtest.New(t)
	created, err := official_climb.Create(db, official_climb.OfficialClimb{
		Name:       "Col de Test",
		StartCoord: geodist.Coord{Lat: 43.1, Lon: 5.1},
		EndCoord:   geodist.Coord{Lat: 43.2, Lon: 5.2},
	})
	require.NoError(t, err)
	assert.Positive(t, created.ID)
	assert.Equal(t, "Col de Test", created.Name)
	assert.Equal(t, geodist.Coord{Lat: 43.1, Lon: 5.1}, created.StartCoord)

	listed, err := official_climb.List(db)
	require.NoError(t, err)
	require.Len(t, listed, 1)
	assert.Equal(t, created.ID, listed[0].ID)

	got, found, err := official_climb.GetByID(db, created.ID)
	require.NoError(t, err)
	require.True(t, found)
	assert.Equal(t, created.EndCoord, got.EndCoord)
	assert.False(t, got.CreatedAt.IsZero())
	assert.False(t, got.UpdatedAt.IsZero())
}

func TestCreateRejectsInvalidOfficialClimb(t *testing.T) {
	db := dbtest.New(t)
	_, err := official_climb.Create(db, official_climb.OfficialClimb{
		Name:       " ",
		StartCoord: geodist.Coord{Lat: 43.1, Lon: 5.1},
		EndCoord:   geodist.Coord{Lat: 43.2, Lon: 5.2},
	})
	assert.EqualError(t, err, "official climb name is required")
}

func TestMatchPolicyRejectsInvalidRadius(t *testing.T) {
	assert.EqualError(t, (official_climb.MatchPolicy{}).Validate(), "official climb endpoint radius must be greater than zero")
}

func TestMatchClimbMatchesWithoutDetectedClimb(t *testing.T) {
	parsed := ride.FromColumns(
		[]float64{0, 1000, 2000, 3000},
		[]float64{100, 150, 200, 100},
		[]geodist.Coord{
			{Lat: 43.10, Lon: 5.10},
			{Lat: 43.11, Lon: 5.11},
			{Lat: 43.12, Lon: 5.12},
			{Lat: 43.13, Lon: 5.13},
		},
		[]time.Time{time.Unix(0, 0), time.Unix(60, 0), time.Unix(120, 0), time.Unix(180, 0)},
	)
	official := official_climb.OfficialClimb{
		Name:       "On route",
		StartCoord: parsed.Coord(1),
		EndCoord:   parsed.Coord(2),
	}
	matched, found := official_climb.MatchClimb(parsed.Coords, official, official_climb.DefaultMatchRadiusM)
	require.True(t, found)
	assert.Equal(t, 1, matched.StartIndex)
	assert.Equal(t, 2, matched.EndIndex)
}

func TestMatchClimbMatchesEndpointInsideRadius(t *testing.T) {
	parsed := ride.FromColumns(
		[]float64{0, 1000, 2000, 3000},
		[]float64{100, 150, 200, 100},
		[]geodist.Coord{
			{Lat: 43.10, Lon: 5.10},
			{Lat: 43.11, Lon: 5.11},
			{Lat: 43.12, Lon: 5.12},
			{Lat: 43.13, Lon: 5.13},
		},
		[]time.Time{time.Unix(0, 0), time.Unix(60, 0), time.Unix(120, 0), time.Unix(180, 0)},
	)
	official := official_climb.OfficialClimb{
		Name:       "Offset from route",
		StartCoord: geodist.Coord{Lat: 43.1101, Lon: 5.1101},
		EndCoord:   geodist.Coord{Lat: 43.1201, Lon: 5.1201},
	}
	matched, found := official_climb.MatchClimb(parsed.Coords, official, official_climb.DefaultMatchRadiusM)
	require.True(t, found)
	assert.Equal(t, 1, matched.StartIndex)
	assert.Equal(t, 2, matched.EndIndex)
}

func TestMatchClimbRejectsReversedEndpoints(t *testing.T) {
	parsed := ride.FromColumns(
		[]float64{0, 1000, 2000, 3000},
		[]float64{100, 150, 200, 100},
		[]geodist.Coord{
			{Lat: 43.10, Lon: 5.10},
			{Lat: 43.11, Lon: 5.11},
			{Lat: 43.12, Lon: 5.12},
			{Lat: 43.13, Lon: 5.13},
		},
		[]time.Time{time.Unix(0, 0), time.Unix(60, 0), time.Unix(120, 0), time.Unix(180, 0)},
	)
	official := official_climb.OfficialClimb{
		Name:       "Reversed",
		StartCoord: parsed.Coord(2),
		EndCoord:   parsed.Coord(1),
	}
	_, found := official_climb.MatchClimb(parsed.Coords, official, official_climb.DefaultMatchRadiusM)
	assert.False(t, found)
}

func TestMatchClimbRejectsEndpointOutsideRadius(t *testing.T) {
	parsed := ride.FromColumns(
		[]float64{0, 1000, 2000, 3000},
		[]float64{100, 150, 200, 100},
		[]geodist.Coord{
			{Lat: 43.10, Lon: 5.10},
			{Lat: 43.11, Lon: 5.11},
			{Lat: 43.12, Lon: 5.12},
			{Lat: 43.13, Lon: 5.13},
		},
		[]time.Time{time.Unix(0, 0), time.Unix(60, 0), time.Unix(120, 0), time.Unix(180, 0)},
	)
	official := official_climb.OfficialClimb{
		Name:       "Too far",
		StartCoord: geodist.Coord{Lat: 43.09, Lon: 5.09},
		EndCoord:   parsed.Coord(2),
	}
	_, found := official_climb.MatchClimb(parsed.Coords, official, 10)
	assert.False(t, found)
}