package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

const FILE_PATH = "./input.txt"

//const FILE_PATH = "./sample.txt"

func LoadInput(filename string) ([]string, error) {
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	var lines []string
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		lines = append(lines, scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		return nil, err
	}

	return lines, nil
}

type Rule struct {
	definition int
	limiter    int
}

type structuredInput struct {
	rules   []Rule
	updates [][]int
}

func TransformInput(lines []string) structuredInput {
	var nums []string
	var num1 int
	var num2 int
	var result structuredInput = structuredInput{}
	var i = 0
	for ; lines[i] != ""; i++ {
		nums = strings.Split(lines[i], "|")
		num1, _ = strconv.Atoi(nums[0])
		num2, _ = strconv.Atoi(nums[1])
		result.rules = append(result.rules, Rule{num1, num2})
	}
	i++
	var c = 0
	for ; i < len(lines); i++ {
		result.updates = append(result.updates, make([]int, 0))
		nums = strings.Split(lines[i], ",")
		for _, num := range nums {
			num1, _ = strconv.Atoi(num)
			result.updates[c] = append(result.updates[c], num1)
		}

		c++
	}

	return result
}

func IsCorrect(rules []Rule, update []int) bool {

	for i, page := range update {
		for _, rule := range rules {
			if rule.definition != page {
				continue
			}

			for j := 0; j < i; j++ {
				if update[j] == rule.limiter {
					return false
				}
			}
		}
	}

	return true
}

func Part1(input structuredInput) int {
	var result = 0

	for _, update := range input.updates {
		if IsCorrect(input.rules, update) {
			result += update[len(update)/2]
		}
	}

	return result
}

func CorrectUpdate(rules []Rule, update []int) []int {
	var result []int = make([]int, len(update))
	copy(result, update)

	var IsCorrect = false
	var temp = 0
	for !IsCorrect {
		IsCorrect = true

		for i, page := range result {
			for _, rule := range rules {
				if rule.definition != page {
					continue
				}

				for j := 0; j < i; j++ {
					if result[j] == rule.limiter {
						temp = result[j]
						result[j] = result[i]
						result[i] = temp
						IsCorrect = false
						break
					}
				}
				if !IsCorrect {
					break
				}
			}
			if !IsCorrect {
				break
			}
		}
	}

	return result
}

func Part2(input structuredInput) int {
	var result = 0

	for _, update := range input.updates {
		if IsCorrect(input.rules, update) {
			continue
		}

		result += CorrectUpdate(input.rules, update)[len(update)/2]
	}

	return result
}

func main() {
	input, err := LoadInput(FILE_PATH)
	if err != nil {
		fmt.Println("Error loading input:", err)
		return
	}

	structuredInput := TransformInput(input)
	fmt.Println("Structured Input:", structuredInput)

	fmt.Println("Solution Part 1: ", Part1(structuredInput))
	fmt.Println("Solution Part 2: ", Part2(structuredInput))
}