import os
from typing import List, Any, Type, Union
from .tools import get_script_dir

BASE_PATH = get_script_dir()
INPUTS_PATH = os.path.join(BASE_PATH, 'inputs')


class AOCDay:
    day: int
    input: List  # our input is always a list of str/lines
    test_solutions_p1: List
    test_solutions_p2: List

    def __init__(self, day: int):
        self.day = day
        with open(os.path.join(INPUTS_PATH, "input%02d" % day)) as f:
            self.input = f.read().splitlines()

    def part1(self) -> Any:
        pass

    def part2(self) -> Any:
        pass

    def test_part1(self, silent: bool = False) -> bool:
        live_input = self.input.copy()
        for case, solution in enumerate(self.test_solutions_p1):
            with open(os.path.join(INPUTS_PATH, "test_input%02d_1_%d" % (self.day, case))) as f:
                self.input = f.read().splitlines()

            check = self.part1()
            if not silent:
                printSolution(self.day, 1, check, solution, case)

            if check != solution:
                if silent:
                    printSolution(self.day, 1, check, solution, case)
                return False

        self.input = live_input
        return True

    def test_part2(self, silent: bool = False) -> bool:
        live_input = self.input.copy()
        for case, solution in enumerate(self.test_solutions_p2):
            with open(os.path.join(INPUTS_PATH, "test_input%02d_2_%d" % (self.day, case))) as f:
                self.input = f.read().splitlines()

            check = self.part2()
            if not silent:
                printSolution(self.day, 2, check, solution, case)

            if check != solution:
                if silent:
                    printSolution(self.day, 2, check, solution, case)
                return False

        self.input = live_input
        return True

    def getInput(self) -> Union[str, List]:
        if len(self.input) == 1:
            return self.input[0]
        else:
            return self.input.copy()

    def getInputListAsType(self, return_type: Type) -> List:
        """
        get input as list casted to return_type, each line representing one list entry
        """
        return [return_type(i) for i in self.input]

    def getMultiLineInputAsArray(self, return_type: Type = None, join_char: str = None) -> List:
        """
        get input for day x as 2d array, split by empty lines
        """
        lines = self.input.copy()
        lines.append('')

        return_array = []
        line_array = []
        for line in lines:
            if not line:
                if join_char:
                    return_array.append(join_char.join(line_array))
                else:
                    return_array.append(line_array)
                line_array = []
                continue

            if return_type:
                line_array.append(return_type(line))
            else:
                line_array.append(line)

        return return_array

    def getInputAsArraySplit(self, split_char: str = ',', return_type: Union[Type, List[Type]] = None) -> List:
        """
        get input for day x with the lines split by split_char
        if input has only one line, returns a 1d array with the values
        if input has multiple lines, returns a 2d array (a[line][values])
        """
        if len(self.input) == 1:
            return splitLine(line=self.input[0], split_char=split_char, return_type=return_type)
        else:
            return_array = []
            for line in self.input:
                return_array.append(splitLine(line=line, split_char=split_char, return_type=return_type))

            return return_array


def printSolution(day: int, part: int, solution: Any, test: Any = None, test_case: int = 0, exec_time: float = None):
    if exec_time is None:
        time_output = ""
    else:
        units = ['s', 'ms', 'µs', 'ns']
        unit = 0
        while exec_time < 1:
            exec_time *= 1000
            unit += 1

        time_output = " (Average run time: %1.2f%s)" % (exec_time, units[unit])

    if test is not None:
        print(
            "%s (TEST day%d/part%d/case%d) -- got '%s' -- expected '%s'%s"
            % ("OK" if test == solution else "FAIL", day, part, test_case, solution, test, time_output)
        )
    else:
        print(
            "Solution to day %s, part %s: %s%s"
            % (
                day,
                part,
                solution,
                time_output
            )
        )


def splitLine(line, split_char: str = ',', return_type: Union[Type, List[Type]] = None):
    if split_char:
        line = line.split(split_char)

    if return_type is None:
        return line
    elif isinstance(return_type, list):
        return [return_type[x](i) if len(return_type) > x else i for x, i in enumerate(line)]
    else:
        return [return_type(i) for i in line]