package day8

import (
	"fmt"
	"os"
	"regexp"
	"strings"
)

func Run() int {
	fmt.Print("hello day 8")
	filename := "day8/example1"
	net, path := Read(filename)
	fmt.Printf("got %+v and %+v\n",net, path)
	result := TraverseNetwork(net, path)
	return result
}

func TraverseNetwork(net Network, path Path) int {
	stepsNum := 0

	curNode := net.Nodes["AAA"]
	for curNode.Name != "ZZZ" {
		direction := path.next()
		var nextNodeName string
		switch direction {
		case 'L':
			nextNodeName = curNode.Left
		case 'R':
			nextNodeName = curNode.Right
		}
		nextNode, found := net.Nodes[nextNodeName]
		if !found {
			panic(fmt.Sprintf("at step %d instruction %s from node %+v results in not found next node %s",
				stepsNum, string(direction), curNode, nextNodeName))
		}
		curNode = nextNode

		stepsNum += 1
	}

	return stepsNum
}

func Read(filename string) (Network, Path) {
	net := Network{
		Nodes: make(map[string]Node),
	}
	bytes, err := os.ReadFile(filename)
	if err != nil {
		panic(fmt.Sprintln("error reading file ", filename))
	}
	lines := strings.Split( string(bytes), "\n")
	path := Path{
		Instruction: strings.TrimSpace( lines[0] ),
	}

	netDescriptions := lines[2:]
	re := regexp.MustCompile(`(?P<NAME>\D{3}) = \((?P<LEFT>\D{3}), (?P<RIGHT>\D{3})\)`)
	nameIndex := re.SubexpIndex("NAME")
	leftIndex := re.SubexpIndex("LEFT")
	rightIndex := re.SubexpIndex("RIGHT")
	for _, line := range netDescriptions {
		if line == "" {
			continue
		}
		match := re.FindStringSubmatch(line)
		if match == nil {
			panic(fmt.Sprintln("error finding match in string : ", line))
		}
		node := Node{
			Name: match[nameIndex],
			Left: match[leftIndex],
			Right: match[rightIndex],
		}
		net.Nodes[node.Name] = node
	}

	return net, path
}

type Node struct {
	Name string
	Left, Right string
}

type Network struct {
	Nodes map[string]Node
}

type Path struct {
	Instruction string
	curStep int
}
func (p *Path)next() rune {
	curInstruction := p.Instruction[p.curStep]
	p.curStep += 1
	if p.curStep == len(p.Instruction) {
		p.curStep = 0
	}
	return rune(curInstruction)
}