package two

import (
	"bytes"
	"slices"

	log "github.com/sirupsen/logrus"

	"github.com/onyx-and-iris/aoc2024/day-05/internal/util"
)

func Solve(buf []byte) (int, error) {
	r := bytes.NewReader(buf)
	data, err := util.ParseLines(r)
	if err != nil {
		return 0, err
	}

	var sum int

	for i, products := range data[1] {
		inOrder := true
		for _, product := range products {
			for _, rulesets := range data[0] {
				if !slices.Contains(rulesets, product) {
					continue
				}

				indx1, indx2 := slices.Index(products, rulesets[0]), slices.Index(products, rulesets[1])
				if indx1 != -1 && indx2 != -1 && indx2 < indx1 {
					inOrder = false
					break
				}
			}
			if !inOrder {
				break
			}
		}
		if !inOrder {
			sum += midOfFixedOrder(data[1][i], data[0])
		}
	}

	return sum, nil
}

func midOfFixedOrder(products []int, rulesets [][]int) int {
	log.Debugf("unordered products: %v", products)

	for {
		var sorts int
		for _, ruleset := range rulesets {
			indx1, indx2 := slices.Index(products, ruleset[0]), slices.Index(products, ruleset[1])
			if indx1 != -1 && indx2 != -1 && indx2 < indx1 {
				products[indx1], products[indx2] = products[indx2], products[indx1]
				sorts++
			}
		}
		if sorts == 0 {
			break
		}
	}

	return products[len(products)/2]
}