package car_fleet

import (
	"fmt"
	"math"
	"slices"
)

type Car struct {
	position int
	speed    int
}

func (c Car) CollidesInto(o Car) float64 {
	if c.speed == o.speed {
		return math.Inf(1)
	}
	return float64(c.position-o.position) / float64(o.speed-c.speed)
}

func (c Car) At(time int) int {
	return c.position + c.speed*time
}

type CarSpace struct {
	car  Car
	from float64
	to   float64
}

func (s CarSpace) Contains(point float64) bool {
	return point >= float64(s.from) && point <= float64(s.to)
}

func sortByInversePosition(a Car, b Car) int {
	return b.position - a.position
}

func CarFleet(target int, position []int, speed []int) int {
	cars := []Car{}
	ends := map[int]bool{}

	for i := range position {
		cars = append(cars, Car{
			position: position[i],
			speed:    speed[i],
		})
	}

	slices.SortFunc(cars, sortByInversePosition)
	stack := []CarSpace{}

	for _, car := range cars {
		for {
			fmt.Println(car, stack)
			if len(stack) == 0 {
				stack = append(stack, CarSpace{
					car:  car,
					from: 0,
					to:   float64(target),
				})
				break
			}

			top := stack[len(stack)-1]
			time := car.CollidesInto(top.car)
			if top.Contains(time) {
				stack[len(stack)-1].from = time
				stack = append(stack, CarSpace{
					car:  car,
					from: 0,
					to:   time,
				})
				break
			}

			stack = stack[:len(stack)-1]
		}

		ending_at := stack[0].car.At(target)
		ends[ending_at] = true
	}

	return len(ends)
}