package day4

import (
	"bufio"
	"errors"
	"fmt"
	"os"
	"strconv"
	"strings"
)

type SectionRange struct {
	start int
	end   int
}

func total_overlap(a SectionRange, b SectionRange) bool {
	return ((a.start >= b.start) && (a.end <= b.end)) ||
		((b.start >= a.start) && (b.end <= a.end))
}

func partial_overlap(a SectionRange, b SectionRange) bool {
	return (a.start >= b.start && a.start <= b.end) ||
		(a.end >= b.end && a.end <= b.end) ||
		(b.start >= a.start && b.start <= a.end) ||
		(b.end >= a.start && b.end <= a.end)
}

func range_from_string(s string) (ret_range SectionRange, err error) {
	ret_range = SectionRange{0, 0}
	items := strings.Split(s, "-")

	if len(items) != 2 {
		err = errors.New("invalid range format")
		return
	}

	start, start_err := strconv.Atoi(items[0])
	if start_err != nil {
		err = start_err
		return
	}
	ret_range.start = start

	end, end_err := strconv.Atoi(items[1])
	if end_err != nil {
		err = end_err
		return
	}
	ret_range.end = end

	err = nil

	return
}

func line_to_pair(s string) (left SectionRange, right SectionRange, err error) {
	items := strings.Split(s, ",")

	if len(items) != 2 {
		err = errors.New("invalid range format")
		return
	}

	left, left_err := range_from_string(items[0])
	if left_err != nil {
		err = left_err
		return
	}

	right, right_err := range_from_string(items[1])
	if right_err != nil {
		err = right_err
		return
	}

	return
}

func Run(filename string) {
	file, err := os.Open(filename)

	if err != nil {
		fmt.Println("Error opening file:", err)
		return
	}

	scanner := bufio.NewScanner(file)
	scanner.Split(bufio.ScanLines)
	var total_overlapping int = 0
	var partial_overlapping int = 0

	for scanner.Scan() {
		line := scanner.Text()
		left, right, err := line_to_pair(line)

		if err != nil {
			fmt.Println("ERROR: failed to parse line:", err)
		} else {
			if total_overlap(left, right) {
				total_overlapping += 1
			}

			if partial_overlap(left, right) {
				partial_overlapping += 1
			}
		}
	}

	file.Close()

	fmt.Println("# of overlapping pairs", total_overlapping)
	fmt.Println("# of partially overlapping pairs", partial_overlapping)
}