package main

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

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 Calculation struct {
	solution int
	numbs    []int
}

type structuredInput = []Calculation

func TransformInput(lines []string) structuredInput {
	var result = make([]Calculation, 0)
	var temp []string
	var solution int
	var numbs []int
	var numb int
	for _, line := range lines {
		numbs = make([]int, 0)
		temp = strings.Split(line, ": ")
		solution, _ = strconv.Atoi(temp[0])
		temp = strings.Split(temp[1], " ")

		for _, snumb := range temp {
			numb, _ = strconv.Atoi(snumb)
			numbs = append(numbs, numb)
		}

		result = append(result, Calculation{solution, numbs})
	}

	return result
}

func RekursiveSolverPart1(result int, index int, calc Calculation) bool {
	if result > calc.solution {
		return false
	}

	if index == len(calc.numbs)-1 {
		return result == calc.solution
	}

	if RekursiveSolverPart1(result+calc.numbs[index+1], index+1, calc) {
		return true
	}

	return RekursiveSolverPart1(result*calc.numbs[index+1], index+1, calc)
}

func CalculateCalibrationResultPart1(calc Calculation) int {
	if RekursiveSolverPart1(calc.numbs[0], 0, calc) {
		return calc.solution
	}
	return 0
}

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

	for _, calc := range input {
		result += CalculateCalibrationResultPart1(calc)
	}

	return result
}

var temp int

func RekursiveSolverPart2(result int, index int, calc Calculation) bool {
	if result > calc.solution {
		return false
	}

	if index == len(calc.numbs)-1 {
		return result == calc.solution
	}

	if RekursiveSolverPart2(result+calc.numbs[index+1], index+1, calc) {
		return true
	}

	if RekursiveSolverPart2(result*calc.numbs[index+1], index+1, calc) {
		return true
	}

	temp, _ = strconv.Atoi(strconv.Itoa(result) + strconv.Itoa(calc.numbs[index+1]))

	return RekursiveSolverPart2(temp, index+1, calc)
}

func CalculateCalibrationResultPart2(calc Calculation) int {
	if RekursiveSolverPart2(calc.numbs[0], 0, calc) {
		return calc.solution
	}
	return 0
}

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

	for _, calc := range input {
		result += CalculateCalibrationResultPart2(calc)
	}

	return result
}

func main() {
	var start time.Time
	var elapsed time.Duration = 0
	input, err := LoadInput(FILE_PATH)
	if err != nil {
		fmt.Println("Error loading input:", err)
		return
	}

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

	start = time.Now()
	fmt.Println("Solution Part 1: ", Part1(structuredInput))
	elapsed = time.Since(start)
	fmt.Printf("Part 1 took %s\n", elapsed)

	start = time.Now()
	fmt.Println("Solution Part 2: ", Part2(structuredInput))
	elapsed = time.Since(start)
	fmt.Printf("Part 2 took %s\n", elapsed)
}