package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
	"strconv"
	"strings"
)

func GetData(s string) []string {
	var result []string
	fileReader, err := os.Open(s)
	if err != nil {
		return nil
	}
	lines := bufio.NewScanner(fileReader)
	lines.Split(bufio.ScanLines)
	for lines.Scan() {
		result = append(result, lines.Text())
	}
	return result
}
func ConvertToUsefulData(s []string) [][]uint {
	a := make([][]uint, len(s[0]))
	for i := range a {
		a[i] = make([]uint, len(s))
	}
	for i, data := range s {
		split := strings.Split(data, "")
		for j, data2 := range split {
			x, _ := strconv.Atoi(data2)
			a[j][i] = uint(x)
		}
	}
	return a
}
func main() {
	result := Part1(ConvertToUsefulData(GetData("./data")))
	fmt.Printf("The Power consumption is: %d\n", result)

	oxy, co2 := Part2(ConvertToUsefulData(GetData("./test-data")))
	for _, f := range data {
		fmt.Println(f)
	}
}

func Part1(data [][]uint) uint {
	gammaRate := uint(0)
	epsilonRate := uint(0)
	for _, rows := range data {
		dict := make(map[uint]uint)
		for _, entry := range rows {
			dict[entry] = dict[entry] + 1
		}
		if dict[0] > dict[1] {
			gammaRate = gammaRate << 1
			epsilonRate = epsilonRate << 1
			epsilonRate, _ = bits.Add(epsilonRate, 1, 0)
		} else {
			gammaRate = gammaRate << 1
			epsilonRate = epsilonRate << 1
			gammaRate, _ = bits.Add(gammaRate, 1, 0)
		}
	}
	//fmt.Printf("Gamma Rate: %b as int (%d)\n", gammaRate, gammaRate)
	//fmt.Printf("Epsilon Rate: %b as int (%d)\n", epsilonRate, epsilonRate)

	return gammaRate * epsilonRate
}

func dataSliceConvert(data [][]uint) [][]uint {
	a := make([][]uint, len(data[0]))
	for i := range a {
		a[i] = make([]uint, len(data))
	}
	for i, row := range data {
		for j, dataEntry := range row {
			a[j][i] = dataEntry
		}
	}
	return a
}

func WhichIsMore(data []uint) int {
	dict := make(map[uint]uint)
	for _, entry := range data {
		dict[entry] = dict[entry] + 1
	}
	if dict[0] == dict[1] {
		return 1
	}
	if dict[0] < dict[1] {
		return 1
	}
	if dict[0] > dict[1] {
		return 0
	}
	return 0
}

func Cycle(data [][]uint, i int) [][]uint {
	var result [][]uint

	test := make([]uint, len(data))
	for j := range data {
		test[j] = data[j][i]
	}
	more := uint(WhichIsMore(test))
	//fmt.Println(more)
	//fmt.Println(test)
	for _, odata := range data {
		if odata[i] == more {
			result = append(result, odata)
		}
	}

	return result
}

func Part2(data [][]uint) (uint, uint) {
	ordered := dataSliceConvert(data)
	for _, d := range ordered {
		fmt.Println(d)
	}

	return 0, 0
}