package examples;

public class Main {
    public static void main(String[] args) {
        var r = new StateStart()
                .transition(new SignalZeroDigit())
                .transition(new SignalZeroDigit())
                .transition(new SignalZeroDigit())
                .transition(new SignalZeroDigit())
                .transition(new SignalNaturalDigit(1))
                .transition(new SignalNaturalDigit(2))
                .transition(new SignalNaturalDigit(3))
                .transition(new SignalPlus())
                .transition(new SignalNaturalDigit(1))
                .transition(new SignalNaturalDigit(2))
                .transition(new SignalNaturalDigit(3))
                .transition(new SignalEq())
                .transition(new SignalNaturalDigit(1))
                .transition(new SignalNaturalDigit(1))
                .transition(new SignalNaturalDigit(1))
                .transition(new SignalNaturalDigit(1))
                .output()
                .value();
        System.out.println(r);
    }
}

sealed interface FSMState<O extends SignalOutput> {
    FSMState<?> transition(SignalInput input);

    O output();
}

record StateStart() implements FSMState<SignalException> {
    @Override
    public State1 transition(SignalInput input) {
        return new State1(new SignalNumber(0));
    }

    @Override
    public SignalException output() {
        return new SignalException();
    }
}

record State1(SignalNumber number) implements FSMState<SignalNumber> {
    public State1 transition(SignalDigit digit) {
        final var nextNumber = number.value() * 10 + digit.digit();
        return new State1(new SignalNumber(nextNumber));
    }

    public State2 transition(SignalPlus plus) {
        return new State2(number, new SignalNumber(0));
    }

    public StateEnd transition(SignalEq eq) {
        return new StateEnd(number);
    }

    @Override
    public FSMState<?> transition(SignalInput input) {
        return switch (input) {
            case SignalDigit digit -> transition(digit);
            case SignalEq eq -> transition(eq);
            case SignalPlus plus -> transition(plus);
        };
    }

    @Override
    public SignalNumber output() {
        return number;
    }
}

record State2(SignalNumber number1, SignalNumber number2) implements FSMState<SignalException> {
    public State2 transition(SignalDigit digit) {
        final var nextNumber = number2.value() * 10 + digit.digit();
        return new State2(number1, new SignalNumber(nextNumber));
    }

    public StateEnd transition(SignalEq eq) {
        final var result = number1.value() + number2.value();
        return new StateEnd(new SignalNumber(result));
    }

    @Override
    public FSMState<?> transition(SignalInput input) {
        return switch (input) {
            case SignalDigit digit -> transition(digit);
            case SignalEq eq -> transition(eq);
            case SignalPlus _ -> this;
        };
    }

    @Override
    public SignalException output() {
        return new SignalException();
    }
}

record StateEnd(SignalNumber number) implements FSMState<SignalNumber> {

    @Override
    public StateEnd transition(SignalInput input) {
        return this;
    }

    @Override
    public SignalNumber output() {
        return number;
    }
}

record SignalEq() implements SignalOperator {
}

record SignalPlus() implements SignalOperator {
}

sealed interface SignalOperator extends SignalInput {
}

sealed interface SignalOutput extends Signal {
}

final class SignalException implements SignalOutput {
}

record SignalNumber(int value) implements SignalOutput {

}

sealed interface SignalInput extends Signal {
}

sealed abstract class SignalDigit implements SignalInput {
    private final int digit;

    public int digit() {
        return digit;
    }

    public SignalDigit(int digit) {
        if (digit > 10 || digit < 0) throw new IllegalArgumentException();
        this.digit = digit;
    }
}

final class SignalNaturalDigit extends SignalDigit {
    public SignalNaturalDigit(int digit) {
        super(digit);
        if (digit > 10 || digit <= 0) throw new IllegalArgumentException();
    }
}

final class SignalZeroDigit extends SignalDigit {
    public SignalZeroDigit() {
        super(0);
    }
}

interface Signal {
}