import collections

from solutions import BaseSolution


class Rule:
    size = 0

    def __init__(self, line):
        pattern, output = line.split(" => ")
        self.pattern = pattern.replace("/", "")
        self.output = output.replace("/", "")
        self.size = int(len(self.pattern) ** 0.5)

        self.patterns = [
            self.pattern,
            self._f(self.pattern),
            self._r(self.pattern),
            self._f(self._r(self.pattern)),
            self._r(self._f(self.pattern)),
            self._r(self._r(self.pattern)),
        ]

    def __repr__(self):
        return "[{}] {} -> {}".format(self.size, self.pattern, self.output)

    def _r(self, b):
        return "".join(
            map(
                lambda g: "".join(g),
                zip(*[b[s : s + self.size] for s in range(0, len(b), self.size)][::-1]),
            )
        )

    def _f(self, b):
        return b[-self.size :] + b[self.size : len(b) - self.size] + b[0 : self.size]

    def matches(self, canvas):
        return canvas in self.patterns

    def enhance(self, canvas):
        return self.output


class Solution(BaseSolution):
    input_file = "21.txt"

    def __str__(self):
        return "Day 21: Fractal Art"

    def _get_block(self, canvas, size, n=0):
        s = ""
        cl = int(len(canvas) ** 0.5)
        x = n % (cl // size)
        y = n // (cl // size)
        for r in range(size):
            start = cl * ((y * size) + r) + (x * size)
            end = start + size
            s += canvas[start:end]
        return s

    def _join_blocks(self, blocks):
        bl = len(blocks)
        c = int(bl**0.5)
        rl = int(len(blocks[0]) ** 0.5)
        canvas = ""
        for i in range(0, bl, c):
            for j in range(rl):
                canvas += "".join(
                    [block[j * rl : (j + 1) * rl] for block in blocks[i : i + c]]
                )
        return canvas

    def solve(self, puzzle_input, iterations=5):
        canvas = ".#...####"
        rules = [Rule(l.strip()) for l in puzzle_input.splitlines()]
        for _ in range(iterations):
            size = 2 if len(canvas) % 2 == 0 else 3
            blocks = len(canvas) // (size**2)
            cb = []
            for b in range(blocks):
                bc = self._get_block(canvas, size, b)
                rule = [r for r in rules if r.matches(bc) and r.size == size]
                if len(rule) > 0:
                    r = rule[0]
                cb.append(r.enhance(bc))
            canvas = self._join_blocks(cb)
        return collections.Counter(canvas)["#"]

    def solve_again(self, puzzle_input):
        return self.solve(puzzle_input, 18)


if __name__ == "__main__":
    solution = Solution()
    solution.show_results()