# https://www.codewars.com/kata/58924f2ca8c628f21a0001a1/
from enum import Enum, auto
from dataclasses import dataclass


class OpKind(Enum):
    LEFT = "<"
    RIGHT = ">"
    INC = "+"
    DEC = "-"
    INPT = ","
    OUTP = "."
    JMPZ = "["
    JMPNZ = "]"


@dataclass
class Opcode:
    kind: OpKind
    operand: int = 1


def stream_tokens(code) -> Opcode:
    for c in code:
        try:
            yield Opcode(OpKind(c))
        except ValueError:
            continue


def optimize(tokens):
    new_tokens = opti_collapse_tokens(tokens)
    if len(new_tokens) <= 1:
        return new_tokens

    tokens = otpi_cancel_opposing(new_tokens)
    while len(new_tokens := otpi_cancel_opposing(tokens)) != len(tokens):
        tokens = new_tokens

    return tokens


def opti_collapse_tokens(tokens):
    # collapse consecutive identical tokens
    new_tokens = []
    for next_token in tokens:
        if new_tokens == []:  # init stack
            new_tokens.append(next_token)
            continue
        current_token = new_tokens.pop()
        if (
            current_token.kind == next_token.kind
            and str(current_token.kind.value) in "<>+-"
        ):
            current_token.operand += 1
            new_tokens.append(current_token)
        else:
            new_tokens.append(current_token)
            new_tokens.append(next_token)
    return new_tokens


def otpi_cancel_opposing(tokens):
    # cancel opposing adjacent tokens
    new_tokens = []
    for next_token in tokens:
        if new_tokens == []:  # init stack
            new_tokens.append(next_token)
            continue
        current_token = new_tokens.pop()
        if (
            current_token.kind.value + next_token.kind.value
            in ("+-", "-+", "<>", "><", "[]")
            and current_token.operand == next_token.operand
        ):
            continue
        else:
            new_tokens.append(current_token)
            new_tokens.append(next_token)
    return new_tokens


def generate_code(tokens):
    out = []
    nest = 0
    # code generation
    for token in tokens:
        match token.kind:
            case OpKind.LEFT:
                out.append(f"{' ' * nest * 2}p -= {token.operand};\n")
            case OpKind.RIGHT:
                out.append(f"{' ' * nest * 2}p += {token.operand};\n")
            case OpKind.INC:
                out.append(f"{' ' * nest * 2}*p += {token.operand};\n")
            case OpKind.DEC:
                out.append(f"{' ' * nest * 2}*p -= {token.operand};\n")
            case OpKind.INPT:
                out.append(f"{' ' * nest * 2}*p = getchar();\n")
            case OpKind.OUTP:
                out.append(f"{' ' * nest * 2}putchar(*p);\n")
            case OpKind.JMPZ:
                out.append(f"{' ' * nest * 2}" + "if (*p) do {\n")
                nest += 1
            case OpKind.JMPNZ:
                nest -= 1
                out.append(f"{' ' * nest * 2}" + "} while (*p);\n")

        if nest < 0:
            return "Error!"

    if nest != 0:
        return "Error!"

    return "".join(out)


def brainfuck_to_c(source_code):
    s = stream_tokens(source_code)
    tokens = optimize(s)
    code = generate_code(tokens)
    return code