from typing import Any, Iterator, List

from aoc import BaseAssignment


class Assignment(BaseAssignment):
    def __init__(self, path, preamble_length=25):
        super().__init__(path)
        self.preamble_length = int(preamble_length)

    def read_input(self, example=False) -> List:
        return list(super(Assignment, self).read_input(example))

    def parse_item(self, item: str) -> Any:
        return int(item)


class AssignmentOne(Assignment):
    def find_invalid(self, input: List, preamble_length: int = 25) -> int:
        preamble = sorted(input[:preamble_length])
        to_check = input[preamble_length]

        front_position = 0
        end_position = preamble_length - 1

        while True:
            if front_position is end_position:
                return to_check

            sum = preamble[front_position] + preamble[end_position]

            if sum > to_check:
                end_position -= 1
            elif sum < to_check:
                front_position += 1
            else:
                break

        return self.find_invalid(input[1:], preamble_length=preamble_length)

    def run(self, input: List) -> int:
        return self.find_invalid(
            input, preamble_length=int(self.preamble_length))


class AssignmentTwo(AssignmentOne):
    def find_weakness(self, input: List, invalid_nr: int) -> int:
        for index, current_num in enumerate(input):
            if index < 2:
                continue

            items_to_check = input[:index]
            sum_list = sum(items_to_check)

            if sum_list > invalid_nr:
                break
            elif sum_list == invalid_nr:
                return min(items_to_check) + max(items_to_check)

        return self.find_weakness(input[1:], invalid_nr)

    def run(self, input: List) -> int:
        return self.find_weakness(input, super().run(input))