If You Give A Seed A Fertilizer

type Map struct {
	Destination uint
	Source      uint
	Range       uint
}

func (m *Map) GetDestination(source uint) (uint, error) {
	if source < m.Source || source >= m.Source+m.Range {
		return 0, errors.New("oob")
	}

	return source + m.Destination - m.Source, nil
}

func (m *Map) GetSource(destination uint) (uint, error) {
	if destination < m.Destination || destination >= m.Destination+m.Range {
		return 0, errors.New("oob")
	}

	return destination - m.Destination + m.Source, nil
}

type MapSet struct {
	Set []Map
}

func (s *MapSet) GetVertices(destinations []uint) []uint {
	vertices := []uint{}
	for _, mapItem := range s.Set {
		vertices = append(vertices, mapItem.Source)
	}
	for _, destination := range destinations {
		vertices = append(vertices, s.GetSource(destination))
	}
	return vertices
}

func (s *MapSet) GetDestination(source uint) uint {
	for i := range s.Set {
		if val, err := s.Set[i].GetDestination(source); err == nil {
			return val
		}
	}

	return source
}

func (s *MapSet) GetSource(destination uint) uint {
	for i := range s.Set {
		if val, err := s.Set[i].GetSource(destination); err == nil {
			return val
		}
	}

	return 0
}

type RecursiveMapSet struct {
	RecursiveSet []MapSet
	Seeds        map[uint]uint
	sync.Mutex
}

func (r *RecursiveMapSet) GetVertices() []uint {
	vertices := []uint{}

	for i := len(r.RecursiveSet) - 1; i >= 0; i-- {
		vertices = r.RecursiveSet[i].GetVertices(vertices)
	}

	return vertices
}

func (r *RecursiveMapSet) GetDestination(source uint) uint {
	for i := 0; i < len(r.RecursiveSet); i++ {
		source = r.RecursiveSet[i].GetDestination(source)
	}

	return source
}

func (r *RecursiveMapSet) SetSeeds(source []uint) {
	for _, seed := range source {
		r.Seeds[seed] = 0
	}
}

func (r *RecursiveMapSet) GetLowestLocation() uint {
	for seed := range r.Seeds {
		r.Seeds[seed] = r.GetDestination(seed)
	}

	seeds := make([]uint, 0, len(r.Seeds))
	for seed := range r.Seeds {
		seeds = append(seeds, seed)
	}

	sort.Slice(seeds, func(i, j int) bool {
		return r.Seeds[seeds[i]] < r.Seeds[seeds[j]]
	})

	return r.Seeds[seeds[0]]
}

func ParseSeeds(line string) []uint {
	line = strings.Split(line, ": ")[1]
	var parsed []uint = []uint{}

	for _, value := range strings.Split(line, " ") {
		if intvalue, err := strconv.Atoi(value); err == nil {
			parsed = append(parsed, uint(intvalue))
		}
	}

	return parsed
}

func ParseMap(line string) (*Map, error) {
	splitLine := strings.Split(line, " ")

	destination, err := strconv.Atoi(splitLine[0])
	if err != nil {
		return nil, err
	}
	source, err := strconv.Atoi(splitLine[1])
	if err != nil {
		return nil, err
	}
	intrange, err := strconv.Atoi(splitLine[2])
	if err != nil {
		return nil, err
	}

	return &Map{
		Destination: uint(destination),
		Source:      uint(source),
		Range:       uint(intrange),
	}, nil
}

func TestMap_GetDestination(t *testing.T) {
	type fields struct {
		Destination uint
		Source      uint
		Range       uint
	}
	tests := []struct {
		name    string
		fields  fields
		source  uint
		want    uint
		wantErr bool
	}{
		{
			name: "Case 0",
			fields: fields{
				Destination: 52,
				Source:      50,
				Range:       48,
			},
			source:  0,
			want:    0,
			wantErr: true,
		},
		{
			name: "Case 49",
			fields: fields{
				Destination: 52,
				Source:      50,
				Range:       48,
			},
			source:  49,
			want:    0,
			wantErr: true,
		},
		{
			name: "Case 50",
			fields: fields{
				Destination: 52,
				Source:      50,
				Range:       48,
			},
			source:  50,
			want:    52,
			wantErr: false,
		},
		{
			name: "Case 97",
			fields: fields{
				Destination: 52,
				Source:      50,
				Range:       48,
			},
			source:  97,
			want:    99,
			wantErr: false,
		},
		{
			name: "Case 98",
			fields: fields{
				Destination: 52,
				Source:      50,
				Range:       48,
			},
			source:  98,
			want:    0,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			m := &seed.Map{
				Destination: tt.fields.Destination,
				Source:      tt.fields.Source,
				Range:       tt.fields.Range,
			}
			got, err := m.GetDestination(tt.source)
			if (err != nil) != tt.wantErr {
				t.Errorf("Map.GetDestination() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("Map.GetDestination() = %v, want %v", got, tt.want)
			}
		})
	}
}

var testSet = seed.MapSet{
	[]seed.Map{
		{
			Destination: 50,
			Source:      98,
			Range:       2,
		},
		{
			Destination: 52,
			Source:      50,
			Range:       48,
		},
	},
}

func TestMapSet_GetDestination(t *testing.T) {
	tests := []struct {
		name   string
		Set    seed.MapSet
		source uint
		want   uint
	}{
		{
			name:   "Case 0",
			Set:    testSet,
			source: 0,
			want:   0,
		},
		{
			name:   "Case 49",
			Set:    testSet,
			source: 49,
			want:   49,
		},
		{
			name:   "Case 50",
			Set:    testSet,
			source: 50,
			want:   52,
		},
		{
			name:   "Case 97",
			Set:    testSet,
			source: 97,
			want:   99,
		},
		{
			name:   "Case 98",
			Set:    testSet,
			source: 98,
			want:   50,
		},
		{
			name:   "Case 99",
			Set:    testSet,
			source: 99,
			want:   51,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.Set.GetDestination(tt.source); got != tt.want {
				t.Errorf("MapSet.GetDestination() = %v, %v => %v", got, tt.source, tt.want)
			}
		})
	}
}

func TestParseSeeds(t *testing.T) {
	t.Run("seeds: 79 14 55 13", func(t *testing.T) {
		if got := seed.ParseSeeds("seeds: 79 14 55 13"); !reflect.DeepEqual(got, []uint{79, 14, 55, 13}) {
			t.Errorf("ParseSeeds(seeds: 79 14 55 13) = %v", got)
		}
	})
}

func TestRecursiveMapSet_GetLowestLocation(t *testing.T) {
	t.Run("Simplest example given", func(t *testing.T) {
		r := &seed.RecursiveMapSet{
			RecursiveSet: []seed.MapSet{testSet},
			Seeds:        map[uint]uint{79: 0, 14: 0, 55: 0, 13: 0},
		}
		if got := r.GetLowestLocation(); got != 13 {
			t.Errorf("RecursiveMapSet.GetDestination() = %v, want 13", got)
		}
	})
}

func (r *RecursiveMapSet) MangleSeeds() {
	seedSlice := []uint{}
	for seed := range r.Seeds {
		seedSlice = append(seedSlice, seed)
	}

	vertices := r.GetVertices()
	mangled := map[uint]uint{}

	for i := 0; i < len(seedSlice)-1; i += 2 {

		for _, vertex := range vertices {
			if vertex >= seedSlice[i] && vertex < seedSlice[i]+seedSlice[i+1] {
				destination := r.GetDestination(vertex)
				if destination == 0 || vertex == 0 {
					continue
				}
				mangled[vertex] = destination
			}
		}

		mangled[seedSlice[i]] = r.GetDestination(seedSlice[i])
		mangled[seedSlice[i]+seedSlice[i+1]] = r.GetDestination(seedSlice[i] + seedSlice[i+1])
	}

	r.Seeds = mangled
}

func main() {
	file, err := os.Open("input.txt")
	if err != nil {
		log.Println(err.Error())
	}
	defer file.Close()
	scanner := bufio.NewScanner(file)

	var (
		rms seed.RecursiveMapSet = seed.RecursiveMapSet{
			Seeds: map[uint]uint{},
		}
		ms seed.MapSet = seed.MapSet{}
	)

	for scanner.Scan() {
		line := scanner.Text()

		if strings.HasPrefix(line, "seeds:") {
			rms.SetSeeds(seed.ParseSeeds(line))
			continue
		}

		if line == "" && len(ms.Set) != 0 {
			rms.RecursiveSet = append(rms.RecursiveSet, ms)
			continue
		}

		if mapItem, err := seed.ParseMap(line); err == nil {
			ms.Set = append(ms.Set, *mapItem)
		} else {
			ms = seed.MapSet{}
		}
	}

	rms.RecursiveSet = append(rms.RecursiveSet, ms)

	lowestLocation1 := rms.GetLowestLocation()
	rms.MangleSeeds()
	lowestLocation2 := rms.GetLowestLocation()

	log.Printf("sum: %d, %d\n", lowestLocation1, lowestLocation2)
}