package main

import (
	"fmt"
	"sort"

	h "git.bullercodeworks.com/brian/adventofcode/helpers"
)

func main() {
	inp := h.StdinToStringSlice()
	part1(inp)
	fmt.Println()
	part2(inp)
}

func part1(inp []string) {
	c := parse(inp)
	var largest int
	for i := range c {
		for j := range c[i:] {
			a := c[i].AreaTo(c[j])
			if a > largest {
				largest = a
			}
		}
	}
	fmt.Println("# Part 1")
	fmt.Println(largest)
}

func part2(inp []string) {
	c := parse(inp)
	var areas []Area
	for i := range c {
		for j := i + 1; j < len(c); j++ {
			areas = append(areas, Area{p1: c[i], p2: c[j], area: c[i].AreaTo(c[j])})
		}
	}
	sort.Slice(areas, func(a, b int) bool { return areas[a].area > areas[b].area })

	var edges []h.Coordinate
	for i := range c {
		var t, n h.Coordinate
		t = c[i]
		if i < len(c)-1 {
			n = c[i+1]
		} else if i == len(c)-1 {
			n = c[0]
		}
		edges = append(edges, getEdges(t, n)...)
	}

	var j int
	h.PrintProgress(j, len(areas))
	for j = 0; j < len(areas); j++ {
		h.ClearProgress()
		h.PrintProgress(j, len(areas))
		var nope bool
		for _, e := range edges {
			if pointIn(e, areas[j]) {
				nope = true
				break
			}
		}
		if nope {
			continue
		}
		break
	}
	fmt.Println("# Part 2")
	fmt.Println(areas[j].area)
}

func getEdges(c1, c2 h.Coordinate) []h.Coordinate {
	var ret []h.Coordinate
	if c1.X == c2.X {
		for y := h.Min(c1.Y, c2.Y); y <= h.Max(c1.Y, c2.Y); y++ {
			ret = append(ret, h.Coordinate{X: c1.X, Y: y})
		}
		return ret
	}
	for x := h.Min(c1.X, c2.X); x <= h.Max(c1.X, c2.X); x++ {
		ret = append(ret, h.Coordinate{X: x, Y: c1.Y})
	}
	return ret
}

func parse(inp []string) []h.Coordinate {
	var allCoords []h.Coordinate
	for i := range inp {
		c := h.Coordinate{}
		fmt.Sscanf(inp[i], "%d,%d", &c.X, &c.Y)
		allCoords = append(allCoords, c)
	}
	return allCoords
}

type Area struct {
	p1, p2 h.Coordinate
	area   int
}

// pointIn returns true if 't' is within the rectangle made
// by Area
func pointIn(t h.Coordinate, a Area) bool {
	return t.X < h.Max(a.p1.X, a.p2.X) && t.X > h.Min(a.p1.X, a.p2.X) &&
		t.Y < h.Max(a.p1.Y, a.p2.Y) && t.Y > h.Min(a.p1.Y, a.p2.Y)
}