# Improved TuringMachine class with debug output and updated transition table per your fix.
from dataclasses import dataclass
from typing import Dict, Tuple, List, TypeAlias, Literal

# === Type Aliases ===
State: TypeAlias = str
Symbol: TypeAlias = str
Direction: TypeAlias = Literal["L", "R"]  # precise directions only

TransitionKey: TypeAlias = Tuple[State, Symbol]
TransitionValue: TypeAlias = Tuple[State, Symbol, Direction]
TransitionFunction: TypeAlias = Dict[TransitionKey, TransitionValue]
Tape: TypeAlias = List[Symbol]


@dataclass
class TuringMachine:
    transition_function: TransitionFunction
    start_state: State
    accept_state: State
    reject_state: State
    blank_symbol: Symbol = " "

    def run(
        self, tape_input: str, max_steps: int = 10_000, verbose: bool = True
    ) -> Tuple[State, Tape]:
        tape: Tape = list(tape_input) + [self.blank_symbol] * 20
        head = 0
        state = self.start_state
        steps = 0

        def debug_print():
            tape_view = "".join(tape).replace(self.blank_symbol, "_")
            head_marker = " " * head + "^"
            print(
                f"[{steps:04}] State: {state} | Head: {head} | Tape:\n{tape_view}\n{head_marker}"
            )

        debug_print()
        while (
            state != self.accept_state
            and state != self.reject_state
            and steps < max_steps
        ):
            if verbose:
                debug_print()
            read = tape[head]
            key = (state, read)
            if key not in self.transition_function:
                print(f"No transition for ({state}, '{read}') — rejecting.")
                state = self.reject_state
                break

            next_state, write, move = self.transition_function[key]
            tape[head] = write
            head += 1 if move == "R" else -1
            if head < 0:
                tape.insert(0, self.blank_symbol)
                head = 0
            state = next_state
            steps += 1

        debug_print()
        return state, tape


# Updated transitions
transitions_cleaned: TransitionFunction = {}

# Scan phase: 1 → X, 0 → Y
transitions_cleaned[("scan", "1")] = ("scan", "X", "R")
transitions_cleaned[("scan", "0")] = ("scan", "Y", "R")

transitions_cleaned[("scan", " ")] = ("back", " ", "L")

# Back phase: move left over 0/1/X/Y and turn forward on ' ', 'M', 'N'
for sym in ["0", "1", "X", "Y"]:
    transitions_cleaned[("back", sym)] = ("back", sym, "L")
transitions_cleaned[("back", " ")] = ("forward", " ", "R")
transitions_cleaned[("back", "M")] = ("forward", "M", "R")
transitions_cleaned[("back", "N")] = ("forward", "N", "R")

# Forward: if blank, done; if digit → sweep; if mark → prepare copy
transitions_cleaned[("forward", " ")] = ("accept", " ", "R")
transitions_cleaned[("forward", "0")] = ("sweep", "0", "L")
transitions_cleaned[("forward", "1")] = ("sweep", "1", "L")
transitions_cleaned[("forward", "X")] = ("fw1", "M", "R")  # 1 → M
transitions_cleaned[("forward", "Y")] = ("fw0", "N", "R")  # 0 → N

# Copy phases
for sym in ["0", "1", "X", "Y"]:  # ts wont ever meet M N
    transitions_cleaned[("fw1", sym)] = ("fw1", sym, "R")
    transitions_cleaned[("fw0", sym)] = ("fw0", sym, "R")
transitions_cleaned[("fw1", " ")] = ("back", "1", "L")
transitions_cleaned[("fw0", " ")] = ("back", "0", "L")

# Sweep phase: M → 1, N → 0
transitions_cleaned[("sweep", "M")] = ("sweep", "1", "L")
transitions_cleaned[("sweep", "N")] = ("sweep", "0", "L")
transitions_cleaned[("sweep", "0")] = ("sweep", "0", "L")
transitions_cleaned[("sweep", "1")] = ("sweep", "1", "L")
transitions_cleaned[("sweep", " ")] = ("accept", " ", "R")

# Build and run the machine with debug output
tm = TuringMachine(
    transition_function=transitions_cleaned,
    start_state="scan",
    accept_state="accept",
    reject_state="reject",
)

final_state, final_tape = tm.run("00110")
print("Final State:", final_state)
print("Final Tape:", "".join(final_tape).strip())