package day5

import (
	"fmt"
	"log"
	"math"
	"os"
	"strconv"
	"strings"
)

type Almanach struct {
	SeedToSoil,
	SoilToFert,
	FertToWater,
	WaterToLight,
	LightToTemp,
	TempToHum,
	HumToLocation EfficientMap
}

type Triplet struct {
	target, source, rangeLen int
}
type EfficientMap struct {
	mappings []Triplet
}

func (m EfficientMap) applyMap(source int) int {
	for _, triplet := range m.mappings {
		sourceStart, sourceEnd := triplet.source, triplet.source + triplet.rangeLen
		if source >= sourceStart && source <= sourceEnd {
			diff := source - sourceStart
			return triplet.target + diff
		}
	}

	return source
}

func applyMap(source int, mapping map[int]int) int {
	var result int
	result, found := mapping[source]
	if !found {
		result = source
	}
	return result
}

func (a Almanach)locationForSeed(seed int) int {
	log.Print("starting calc of location for seed %d", seed)
	soil := a.SeedToSoil.applyMap(seed)
	fert := a.SoilToFert.applyMap(soil)
	water := a.FertToWater.applyMap(fert)
	light := a.WaterToLight.applyMap(water)
	temp := a.LightToTemp.applyMap(light)
	hum := a.TempToHum.applyMap(temp)
	location := a.HumToLocation.applyMap(hum)
	return location
}

func Run() int {
	fmt.Println("the day 5")
	inputDir := "day5/input"
	seedToSoil := fmt.Sprint(inputDir, "/seed-to-soil")
	log.Print("finished seed map")
	soilToFert := fmt.Sprint(inputDir, "/soil-to-fertilizer")
	log.Print("finished soil map")
	fertToWater := fmt.Sprint(inputDir, "/fertilizer-to-water")
	log.Print("finished fert map")
	waterToLight := fmt.Sprint(inputDir, "/water-to-light")
	log.Print("finished water map")
	lightToTemp := fmt.Sprint(inputDir, "/light-to-temperature")
	log.Print("finished light map")
	tempToHum := fmt.Sprint(inputDir, "/temperature-to-humidity")
	log.Print("finished temp map")
	humToLocation := fmt.Sprint(inputDir, "/humidity-to-location")

	seedsFileName := fmt.Sprint(inputDir, "/seeds")
	seedsBytes, err := os.ReadFile(seedsFileName)
	if err != nil {
		panic(fmt.Sprint("error reading seeds file ", seedsFileName))
	}
	seedsLine := string(seedsBytes)
	var seeds []int
	for _, seedStr := range strings.Fields(seedsLine) {
		seed, err := strconv.Atoi(seedStr)
		if err != nil {
			panic(fmt.Sprint("can't read seeds ", seedStr))
		}
		seeds = append(seeds, seed)
	}
	log.Print("finished for seeds file", seeds)

	almanach := Almanach{
		SeedToSoil: ReadMap(seedToSoil),
		SoilToFert: ReadMap(soilToFert),
		FertToWater: ReadMap(fertToWater),
		WaterToLight: ReadMap(waterToLight),
		LightToTemp: ReadMap(lightToTemp),
		TempToHum: ReadMap(tempToHum),
		HumToLocation: ReadMap(humToLocation),
	}
	log.Print("created almanach")

	result := math.MaxInt
	log.Print("before seed range")
	for _, seed := range seeds {
		log.Printf("checking for seed %d", seed)
		location := almanach.locationForSeed(seed)
		if location < result {
			result = location
		}
	}

	return result
}

func ReadMap(filename string) EfficientMap {
	log.Printf("reading in map from %s", filename)
	result := make([]Triplet, 0)
	bytes, err := os.ReadFile(filename)
	if err != nil {
		panic(fmt.Sprintf("error reading file %s", filename))
	}
	text := string(bytes)
	text = strings.TrimSpace(text)
	for _, line := range strings.Split(text, "\n") {
		nums := strings.Fields(line)
		if len(nums) != 3 {
			panic(fmt.Sprint("error, map line doesn't have 3 nums: ", line, nums))
		}
		destinaitonStart, err1 := strconv.Atoi(nums[0])
		sourceStart, err2 := strconv.Atoi(nums[1])
		rangeLength, err3 := strconv.Atoi(nums[2])
		if err1 != nil || err2 != nil || err3 != nil {
			panic(fmt.Sprint("error converting one of the numbers: ", nums))
		}
		result = append(result, Triplet{destinaitonStart, sourceStart, rangeLength})
	}

	return EfficientMap{result}
}