import os
import tempfile
from datetime import timedelta

import pytest
from django.contrib.auth import get_user_model
from django.core.files import File

from locations.models import GeoLocation
from scrobbles.importers.trail_gpx import (
    import_trail_gpx,
    parse_trackpoints,
)
from scrobbles.models import Scrobble, TrailGPXImport
from trails.models import Trail

User = get_user_model()

SAMPLE_GPX = os.path.join(
    os.path.dirname(__file__), "..", "..", "data", "sample_trail.gpx"
)


@pytest.fixture
def user(db):
    return User.objects.create(email="trailblazer@example.com")


@pytest.fixture
def sample_gpx_path():
    return SAMPLE_GPX


class TestParseTrackpoints:
    def test_parses_gpx(self, sample_gpx_path):
        points, name = parse_trackpoints(sample_gpx_path)
        assert len(points) == 837
        assert name == "Morning Run ⛅"
        lat, lon, ele, t = points[0]
        assert round(lat, 6) == 34.190598
        assert round(lon, 6) == -118.844015
        assert ele == 305.3
        assert t is not None

    def test_first_and_last_times(self, sample_gpx_path):
        points, _ = parse_trackpoints(sample_gpx_path)
        first_time = points[0][3]
        last_time = points[-1][3]
        duration = (last_time - first_time).total_seconds()
        assert duration == pytest.approx(3770, abs=5)


class TestImportTrailGPX:
    def test_creates_trail(self, user, sample_gpx_path):
        import_trail_gpx(sample_gpx_path, user.id)
        assert Trail.objects.filter(title="Morning Run ⛅").exists()

    def test_creates_geolocation(self, user, sample_gpx_path):
        import_trail_gpx(sample_gpx_path, user.id)
        assert GeoLocation.objects.filter(lat=34.190598, lon=-118.844015).exists()

    def test_sets_trailhead(self, user, sample_gpx_path):
        import_trail_gpx(sample_gpx_path, user.id)
        trail = Trail.objects.filter(title="Morning Run ⛅").first()
        assert trail.trailhead_location is not None
        assert round(trail.trailhead_location.lat, 6) == 34.190598

    def test_creates_scrobble(self, user, sample_gpx_path):
        import_trail_gpx(sample_gpx_path, user.id)
        assert Scrobble.objects.filter(source="GPX Import").count() == 1

    def test_scrobble_timestamps(self, user, sample_gpx_path):
        import_trail_gpx(sample_gpx_path, user.id)
        scrobble = Scrobble.objects.filter(source="GPX Import").first()
        assert scrobble.timestamp.isoformat().startswith("2022-06-05T13:55:09")
        assert scrobble.stop_timestamp.isoformat().startswith("2022-06-05T14:57:59")
        assert scrobble.media_type == Scrobble.MediaType.TRAIL

    def test_scrobble_has_trail_fk(self, user, sample_gpx_path):
        import_trail_gpx(sample_gpx_path, user.id)
        scrobble = Scrobble.objects.filter(source="GPX Import").first()
        assert scrobble.trail is not None
        assert scrobble.trail.title == "Morning Run ⛅"

    def test_scrobble_has_gpx_file(self, user, sample_gpx_path):
        import_trail_gpx(sample_gpx_path, user.id)
        scrobble = Scrobble.objects.filter(source="GPX Import").first()
        assert scrobble.gpx_file
        assert scrobble.gpx_file.name.endswith(".gpx")

    def test_lookup_existing_trail_by_trailhead(self, user, sample_gpx_path):
        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
        trail = Trail.objects.create(title="Existing Trail", trailhead_location=geo)
        import_trail_gpx(sample_gpx_path, user.id)
        scrobble = Scrobble.objects.filter(source="GPX Import").first()
        assert scrobble.trail.id == trail.id

    def test_dedup(self, user, sample_gpx_path):
        import_trail_gpx(sample_gpx_path, user.id)
        import_trail_gpx(sample_gpx_path, user.id)
        assert Scrobble.objects.filter(source="GPX Import").count() == 1


class TestTrailGPXImportModel:
    def test_create_import_model(self, db, user, sample_gpx_path):
        imp = TrailGPXImport.objects.create(
            user=user,
            original_filename="test_trail.gpx",
        )
        assert imp.uuid is not None
        assert imp.import_type == "Trail GPX"

    @pytest.mark.django_db(transaction=True)
    def test_process_via_model(self, user, sample_gpx_path):
        imp = TrailGPXImport.objects.create(
            user=user,
            original_filename="Morning Run.gpx",
        )
        with open(sample_gpx_path, "rb") as f:
            imp.gpx_file.save("Morning Run.gpx", File(f), save=True)
        imp.process()
        imp.refresh_from_db()
        assert imp.process_count == 1
        assert imp.processed_finished is not None


class TestFindByTrailhead:
    def test_exact_match(self, db):
        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
        trail = Trail.objects.create(title="Test Trail", trailhead_location=geo)
        found = Trail.find_by_trailhead(34.190598, -118.844015)
        assert found == trail

    def test_within_tolerance(self, db):
        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
        trail = Trail.objects.create(title="Nearby Trail", trailhead_location=geo)
        found = Trail.find_by_trailhead(34.191000, -118.844000, tolerance_m=100)
        assert found == trail

    def test_beyond_tolerance(self, db):
        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
        Trail.objects.create(title="Far Trail", trailhead_location=geo)
        found = Trail.find_by_trailhead(34.200000, -118.850000, tolerance_m=50)
        assert found is None

    def test_no_trailhead_returns_none(self, db):
        Trail.objects.create(title="No Location")
        found = Trail.find_by_trailhead(34.190598, -118.844015)
        assert found is None


class TestFindOrCreate:
    def test_find_existing(self, db):
        Trail.objects.create(title="Existing Trail")
        trail = Trail.find_or_create("Existing Trail")
        assert trail.title == "Existing Trail"

    def test_create_new(self, db):
        trail = Trail.find_or_create("New Trail")
        assert trail.title == "New Trail"
        assert Trail.objects.count() == 1