package main

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

type Operation int

const (
	OPERATION_ADD      = Operation(0)
	OPERATION_MULTIPLY = Operation(1)
	OPERATION_CONCAT   = Operation(2)
)

type Equation struct {
	Result       int
	Coefficients []int
}

func (e *Equation) IsValid() bool {
	// here we need to generate an operation slice of len e.Coefficients-1 and fill it with each combination
	// of both operations (e.g., if len(ops) == 3, we have {+,+,+}, {+,+,*}, {+,*,*}, etc.
	permutations := GenerateOperationPermutations(len(e.Coefficients) - 1)
	for _, permutation := range permutations {
		if e.Solve(permutation) {
			return true
		}
	}

	return false
}

// Solve method tries to solve the equation with the given operations in sequential order
func (e *Equation) Solve(ops []Operation) bool {
	// this logic goes like this: take two coefficients and combine them over the operation
	if len(ops) != len(e.Coefficients)-1 {
		log.Printf("too few operations, got %v, expected %v", len(ops), len(e.Coefficients)-1)
		return false
	}

	// log.Println("solving", ops)
	// the amount of operations need to be len(e.Coefficients)-1
	rhsIndex := 1
	acc := e.Coefficients[0]
	for _, op := range ops {
		rhs := e.Coefficients[rhsIndex]

		switch op {
		case OPERATION_ADD:
			acc = acc + rhs
		case OPERATION_MULTIPLY:
			acc = acc * rhs
		case OPERATION_CONCAT:
			ii, _ := strconv.Atoi(fmt.Sprintf("%v%v", acc, rhs))
			acc = ii
		}

		rhsIndex++
	}

	return acc == e.Result
}

// GenerateOperationPermutations generates all permutations of all operations
// of the given length
func GenerateOperationPermutations(length int) [][]Operation {
	// we need space for 2^length combinations
	combs := int(math.Pow(3.0, float64(length)))

	res := make([][]Operation, combs)
	for i := 0; i < combs; i++ {
		cmb := make([]Operation, length)
		binaryString := fmt.Sprintf("%0*s", length, strconv.FormatInt(int64(i), 3))
		for j, char := range binaryString {
			cmb[j] = Operation(int(char - '0'))
		}
		res[i] = cmb
	}

	return res
}

func main() {
	input, err := os.ReadFile("input")
	if err != nil {
		panic(err)
	}

	lines := strings.Split(string(input), "\n")

	solveFirst(lines[:len(lines)-1])
	solveSecond(lines[:len(lines)-1])
}

func solveFirst(input []string) {
	res := 0
	for _, line := range input {
		eq := parseLine(line)
		if eq.IsValid() {
			res += eq.Result
		}
	}

	log.Println("result:", res)
}

func solveSecond(input []string) {
	// whoops
}

func parseLine(line string) *Equation {
	splitLine := strings.Split(line, ":")
	coeffs := strings.Split(splitLine[1], " ")

	resInt, _ := strconv.Atoi(splitLine[0])
	eq := &Equation{
		Result:       resInt,
		Coefficients: make([]int, 0),
	}

	for _, coeff := range coeffs {
		ii, _ := strconv.Atoi(coeff)
		if ii != 0 {
			eq.Coefficients = append(eq.Coefficients, ii)
		}
	}

	return eq
}