''

package main

import (
	"fmt"

	"github.com/stephensli/aoc/helpers/algorithms"
	"github.com/stephensli/aoc/helpers/aoc"
	"github.com/stephensli/aoc/helpers/file"
	"github.com/stephensli/aoc/helpers/printers"
)

func parse(grid [][]string) [][]*Position {
	positions := make([][]*Position, len(grid))

	galexyIndex := 1

	for i := 0; i < len(grid); i++ {
		row := make([]*Position, len(grid[i]))
		positions[i] = row

		for j := 0; j < len(grid[i]); j++ {
			position := &Position{
				PositionType:  EmptySpaceType,
				PositionValue: 0,
			}

			if grid[i][j] == "#" {
				position.PositionType = GalexySpaceType
				position.PositionValue = galexyIndex
				galexyIndex += 1
			}

			row[j] = position
		}
	}

	return positions
}

func expandSpace(grid [][]*Position) [][]*Position {
	// rows
	emptyRow := []*Position{}
	for i := 0; i < len(grid); i++ {
		emptyRow = append(emptyRow, &Position{
			Coords:        algorithms.Coords{},
			PositionType:  0,
			PositionValue: 0,
		})
	}

	for i := 0; i < len(grid); i++ {
		empty := true

		for j := 0; j < len(grid[i]); j++ {
			if grid[i][j].Galexy() {
				empty = false
				break
			}
		}

		if empty {
			grid = append(grid[:i+1], grid[i:]...)
			grid[i] = emptyRow
			i += 1
		}
	}

	// columns
	for i := 0; i < len(grid[0]); i++ {
		empty := true

		for j := 0; j < len(grid); j++ {
			if grid[j][i].Galexy() {
				empty = false
				break
			}
		}

		if empty {
			for j := 0; j < len(grid); j++ {
				grid[j] = append(grid[j][:i+1], grid[j][i:]...)
				grid[j][i] = &Position{
					Coords:        algorithms.Coords{},
					PositionType:  0,
					PositionValue: 0,
				}
			}

			i += 1
		}
	}

	return grid
}

func getGalexyPositions(grid [][]*Position) ([]algorithms.Coords, map[int]algorithms.Coords) {
	list := []algorithms.Coords{}
	mapView := map[int]algorithms.Coords{}

	for i, v := range grid {
		for j, p := range v {
			if p.Galexy() {
				list = append(list, algorithms.Coords{X: i, Y: j})
				mapView[p.PositionValue] = algorithms.Coords{X: i, Y: j}
			}
		}
	}

	return list, mapView
}

func main() {
	path, complete := aoc.Setup(2023, 11, true)
	defer complete()

	grid := expandSpace(parse(file.ToTextSplit(path, "")))
	_, galexiesMappings := getGalexyPositions(grid)
	//galexies, galexiesMappings := getGalexyPositions(grid)

	printers.PrettyPrintGird(grid)

	p1 := 0
	//history := map[string]bool{}

	var nodes [][]algorithms.Node
	for i, v := range grid {
		var innerNodes []algorithms.Node
		for j, p := range v {
			p.Coords = algorithms.Coords{X: i, Y: j}
			innerNodes = append(innerNodes, p)
		}
		nodes = append(nodes, innerNodes)
	}

	//	for i, c := range galexies {
	//		for j, c2 := range galexies {
	//			historykeyOne := fmt.Sprintf("%d:%d:%d:%d", c.X, c.Y, c2.X, c2.Y)
	//			historykeyTwo := fmt.Sprintf("%d:%d:%d:%d", c2.X, c2.Y, c.X, c.Y)
	//
	//			if i != j && !history[historykeyOne] && !history[historykeyTwo] {
	//				history[historykeyOne] = true
	//				history[historykeyTwo] = true
	//
	//				fmt.Printf("grid[c.X][c.Y].PositionValue: %v\n", grid[c.X][c.Y].PositionValue)
	//				fmt.Printf("grid[c2.X][c2.Y].PositionValue: %v\n\n", grid[c2.X][c2.Y].PositionValue)
	//
	//				shortest, distance, previous := algorithms.DijkstraGrid(nodes, algorithms.NonDigagnonalDirections, c, c2)
	//				p1 += shortest
	//
	//				fmt.Printf("distance: %v\n", distance)
	//				fmt.Printf("previous: %v\n", previous)
	//			}
	//		}
	//	}

	fmt.Println()
	fmt.Println()
	fmt.Println()
	fmt.Println()

	shortest, distance, previous := algorithms.DijkstraGrid(nodes, algorithms.NonDigagnonalDirections,
		galexiesMappings[1], galexiesMappings[4])

	for _, n := range distance {
	//	if n.(*Position).Galexy() {
	//		continue
	//	}

		fmt.Printf("n.Position(): %v\n", n.Position())

		grid[n.Position().X][n.Position().Y] = &Position{
			Coords:        n.Position(),
			PositionType:  Filled,
			PositionValue: 0,
		}
	}

	fmt.Printf("shortest: %v\n", shortest)
	fmt.Printf("distance: %v\n", distance)
	fmt.Printf("previous: %v\n", previous)

	printers.PrettyPrintGird(grid)

	aoc.PrintAnswer(1, p1)
	aoc.PrintAnswer(2, path)
}