package ride

import (
	"errors"
	"fmt"
	"io"
	"os"
	"strconv"
	"strings"
	"time"

	"github.com/jftuga/geodist"
	"github.com/martinlehoux/biking_home/climb"
	"github.com/martinlehoux/kagamigo/kcore"
	"github.com/tkrajina/gpxgo/gpx"
)

const garminTrackPointExtensionNamespace = "http://www.garmin.com/xmlschemas/TrackPointExtension/v1"

var ErrNoTrackPoints = errors.New("ride has no track points")

type Ride struct {
	climb.Route
	timestamps []time.Time
	heartRates []float64
	cadences   []float64
	powers     []float64
}

func (r *Ride) check() {
	kcore.Assert(r.Len() > 0, "no points in ride")
	kcore.Assert(len(r.Distances) == len(r.Elevations), "ride columns have different lengths")
	kcore.Assert(len(r.Distances) == len(r.Coords), "ride columns have different lengths")
	kcore.Assert(len(r.Distances) == len(r.timestamps), "ride columns have different lengths")
	for _, column := range [][]float64{r.heartRates, r.cadences, r.powers} {
		if len(column) > 0 {
			kcore.Assert(len(r.Distances) == len(column), "ride columns have different lengths")
		}
	}
}

func (r Ride) Len() int {
	return len(r.Distances)
}

func (r Ride) Timestamps() []time.Time { return r.timestamps }

func (r Ride) Powers() ([]float64, bool) { return optionalComponent(r.powers) }

func (r Ride) Cadences() ([]float64, bool) { return optionalComponent(r.cadences) }

func (r Ride) HeartRates() ([]float64, bool) { return optionalComponent(r.heartRates) }

func optionalComponent(column []float64) ([]float64, bool) {
	if len(column) == 0 {
		return nil, false
	}
	return column, true
}

type RideParser interface {
	Parse(reader io.Reader) (Ride, error)
}

func ParseFile(parser RideParser, filename string) (Ride, error) {
	f, err := os.Open(filename)
	if err != nil {
		return Ride{}, err
	}
	defer f.Close()
	return parser.Parse(f)
}

type GPXRideParser struct{}

func (p GPXRideParser) Parse(reader io.Reader) (Ride, error) {
	content, err := gpx.Parse(reader)
	if err != nil {
		return Ride{}, err
	}
	if len(content.Tracks) == 0 || len(content.Tracks[0].Segments) == 0 {
		return Ride{}, ErrNoTrackPoints
	}
	segment := content.Tracks[0].Segments[0]
	if len(segment.Points) == 0 {
		return Ride{}, ErrNoTrackPoints
	}
	distances := make([]float64, 0, len(segment.Points))
	elevations := make([]float64, 0, len(segment.Points))
	coords := make([]geodist.Coord, 0, len(segment.Points))
	timestamps := make([]time.Time, 0, len(segment.Points))
	heartRates := make([]float64, 0, len(segment.Points))
	cadences := make([]float64, 0, len(segment.Points))
	powers := make([]float64, 0, len(segment.Points))
	heartRateComplete := true
	cadenceComplete := true
	powerComplete := true
	distance := 0.0
	previous := segment.Points[0]
	if previous.Elevation.Null() {
		return Ride{}, errors.New("points without elevation")
	}
	distances = append(distances, 0)
	elevations = append(elevations, previous.Elevation.Value())
	coords = append(coords, geodist.Coord{Lat: previous.Latitude, Lon: previous.Longitude})
	timestamps = append(timestamps, previous.Timestamp)
	sample, err := metricSampleForPoint(previous)
	if err != nil {
		return Ride{}, err
	}
	appendMetric(&heartRates, &heartRateComplete, sample.heartRate)
	appendMetric(&cadences, &cadenceComplete, sample.cadence)
	appendMetric(&powers, &powerComplete, sample.power)
	for i := 1; i < len(segment.Points); i++ {
		p := segment.Points[i]
		distance += p.Distance2D(&previous)
		previous = p
		if distance == 0 {
			continue
		}
		if p.Elevation.Null() {
			return Ride{}, errors.New("points without elevation")
		}
		distances = append(distances, distance)
		elevations = append(elevations, p.Elevation.Value())
		coords = append(coords, geodist.Coord{Lat: p.Latitude, Lon: p.Longitude})
		timestamps = append(timestamps, p.Timestamp)
		sample, err = metricSampleForPoint(p)
		if err != nil {
			return Ride{}, err
		}
		appendMetric(&heartRates, &heartRateComplete, sample.heartRate)
		appendMetric(&cadences, &cadenceComplete, sample.cadence)
		appendMetric(&powers, &powerComplete, sample.power)
	}
	if len(distances) < 2 {
		return Ride{}, errors.New("zero distance")
	}
	var heartRatesColumn, cadencesColumn, powersColumn []float64
	if heartRateComplete {
		heartRatesColumn = heartRates
	}
	if cadenceComplete {
		cadencesColumn = cadences
	}
	if powerComplete {
		powersColumn = powers
	}
	return fromColumns(distances, elevations, coords, timestamps, heartRatesColumn, cadencesColumn, powersColumn), nil
}

func FromColumns(distances []float64, elevations []float64, coords []geodist.Coord, timestamps []time.Time) Ride {
	return fromColumns(distances, elevations, coords, timestamps, nil, nil, nil)
}

// FromColumnsWithMetrics builds a Ride from its columns, including optional
// heart-rate, cadence and power components of the same length as the other
// columns.
func FromColumnsWithMetrics(distances []float64, elevations []float64, coords []geodist.Coord, timestamps []time.Time, heartRates, cadences, powers []float64) Ride {
	return fromColumns(distances, elevations, coords, timestamps, heartRates, cadences, powers)
}

func fromColumns(distances []float64, elevations []float64, coords []geodist.Coord, timestamps []time.Time, heartRates, cadences, powers []float64) Ride {
	ride := Ride{
		Distances:  distances,
		Elevations: elevations,
		Coords:     coords,
		timestamps: timestamps,
		heartRates: heartRates,
		cadences:   cadences,
		powers:     powers,
	}
	ride.check()
	return ride
}

type metricSample struct {
	heartRate *float64
	cadence   *float64
	power     *float64
}

func metricSampleForPoint(point gpx.GPXPoint) (metricSample, error) {
	heartRate, err := metricValue(point, "hr")
	if err != nil {
		return metricSample{}, err
	}
	cadence, err := metricValue(point, "cad")
	if err != nil {
		return metricSample{}, err
	}
	power, err := metricValue(point, "watts")
	if err != nil {
		return metricSample{}, err
	}
	return metricSample{heartRate: heartRate, cadence: cadence, power: power}, nil
}

func appendMetric(column *[]float64, complete *bool, value *float64) {
	if value == nil {
		*complete = false
		*column = append(*column, 0)
		return
	}
	*column = append(*column, *value)
}

func metricValue(point gpx.GPXPoint, name string) (*float64, error) {
	trackPointExtension, found := point.Extensions.GetNode(gpx.NamespaceURL(garminTrackPointExtensionNamespace), "TrackPointExtension")
	if !found {
		return nil, nil
	}
	node, found := trackPointExtension.GetNode(name)
	if !found {
		return nil, nil
	}
	value, err := strconv.ParseFloat(strings.TrimSpace(node.Data), 64)
	if err != nil {
		return nil, fmt.Errorf("invalid Garmin %s value %q: %w", name, node.Data, err)
	}
	return &value, nil
}

func (ride Ride) Cotacol() float64 {
	return climb.Cotacol(ride.Distances, ride.Elevations)
}