상태 패턴

using System;

public enum ReviewStage { Draft, InReview, Published }
public enum ReviewAction { Submit, Approve, Reject }

public static class ReviewTransitions
{
    public static ReviewStage Next(ReviewStage stage, ReviewAction action) =>
        (stage, action) switch
        {
            (ReviewStage.Draft, ReviewAction.Submit) => ReviewStage.InReview,
            (ReviewStage.InReview, ReviewAction.Approve) => ReviewStage.Published,
            (ReviewStage.InReview, ReviewAction.Reject) => ReviewStage.Draft,
            _ => throw new InvalidOperationException("허용되지 않은 전이입니다.")
        };
}

public sealed class ReviewDocument
{
    private string content;
    private DocumentState state = new DraftState(null);

    public string Content => content;
    public ReviewStage Stage => state.Stage;
    public string? RejectionReason => state.RejectionReason;

    public ReviewDocument(string content)
    {
        this.content = RequireText(content, nameof(content));
    }

    public void Edit(string content) =>
        state.Edit(this, RequireText(content, nameof(content)));

    public void Submit() => state.Submit(this);
    public void Approve() => state.Approve(this);

    public void Reject(string reason) =>
        state.Reject(this, RequireText(reason, nameof(reason)));

    private static string RequireText(string value, string parameterName)
    {
        if (string.IsNullOrWhiteSpace(value))
            throw new ArgumentException("비어 있지 않은 내용이 필요합니다.", parameterName);
        return value;
    }

    private abstract class DocumentState
    {
        public abstract ReviewStage Stage { get; }
        public virtual string? RejectionReason => null;

        // 상태별로 허용한 동작만 재정의한다. 나머지는 명시적으로 거부한다.
        public virtual void Edit(ReviewDocument document, string content) =>
            throw Denied(nameof(Edit));
        public virtual void Submit(ReviewDocument document) =>
            throw Denied(nameof(Submit));
        public virtual void Approve(ReviewDocument document) =>
            throw Denied(nameof(Approve));
        public virtual void Reject(ReviewDocument document, string reason) =>
            throw Denied(nameof(Reject));

        private InvalidOperationException Denied(string operation) =>
            new($"{Stage} 상태에서는 {operation} 요청을 처리할 수 없습니다.");
    }

    private sealed class DraftState : DocumentState
    {
        public override ReviewStage Stage => ReviewStage.Draft;
        public override string? RejectionReason { get; }

        public DraftState(string? rejectionReason)
        {
            RejectionReason = rejectionReason;
        }

        public override void Edit(ReviewDocument document, string content) =>
            document.content = content;

        public override void Submit(ReviewDocument document) =>
            document.state = new InReviewState();
    }

    private sealed class InReviewState : DocumentState
    {
        public override ReviewStage Stage => ReviewStage.InReview;

        public override void Approve(ReviewDocument document) =>
            document.state = new PublishedState();

        public override void Reject(ReviewDocument document, string reason) =>
            document.state = new DraftState(reason);
    }

    private sealed class PublishedState : DocumentState
    {
        public override ReviewStage Stage => ReviewStage.Published;
    }
}

public static class Program
{
    private static int checks;

    public static void Main()
    {
        var document = new ReviewDocument("첫 초안");
        Equal(ReviewStage.Draft, document.Stage);
        Equal("첫 초안", document.Content);
        Equal<string?>(null, document.RejectionReason);
        document.Edit("수정한 초안");
        Equal("수정한 초안", document.Content);
        document.Submit();
        Equal(ReviewStage.InReview, document.Stage);
        document.Reject("근거를 보강해 주세요");
        Equal(ReviewStage.Draft, document.Stage);
        Equal("근거를 보강해 주세요", document.RejectionReason);
        document.Edit("근거를 보강한 본문");
        Equal("근거를 보강해 주세요", document.RejectionReason);
        document.Submit();
        Equal<string?>(null, document.RejectionReason);
        document.Approve();
        Equal(ReviewStage.Published, document.Stage);
        Equal("근거를 보강한 본문", document.Content);

        Expect<ArgumentException>(() => new ReviewDocument(" "));
        Expect<ArgumentException>(() => new ReviewDocument(null!));
        var draft = new ReviewDocument("본문");
        Expect<ArgumentException>(() => draft.Edit(" "));
        Equal("본문", draft.Content);
        var inReview = At(ReviewStage.InReview);
        Expect<ArgumentException>(() => inReview.Reject(" "));
        Equal(ReviewStage.InReview, inReview.Stage);

        // 모든 상태와 요청의 조합을 확인한다. 금지된 요청은 상태와 내용을 보존한다.
        foreach (var stage in Enum.GetValues<ReviewStage>())
        {
            foreach (var action in Enum.GetValues<ReviewAction>())
            {
                var item = At(stage);
                var before = (item.Stage, item.Content, item.RejectionReason);
                bool allowed = (stage, action) is
                    (ReviewStage.Draft, ReviewAction.Submit) or
                    (ReviewStage.InReview, ReviewAction.Approve) or
                    (ReviewStage.InReview, ReviewAction.Reject);

                if (allowed)
                {
                    var expected = ReviewTransitions.Next(stage, action);
                    Execute(item, action);
                    Equal(expected, item.Stage);
                    Equal("본문", item.Content);
                }
                else
                {
                    Expect<InvalidOperationException>(() => ReviewTransitions.Next(stage, action));
                    Expect<InvalidOperationException>(() => Execute(item, action));
                    Equal(before, (item.Stage, item.Content, item.RejectionReason));
                }
            }
        }

        foreach (var stage in new[] { ReviewStage.InReview, ReviewStage.Published })
        {
            var item = At(stage);
            var before = (item.Stage, item.Content, item.RejectionReason);
            Expect<InvalidOperationException>(() => item.Edit("새 본문"));
            Equal(before, (item.Stage, item.Content, item.RejectionReason));
        }
        Expect<InvalidOperationException>(() => ReviewTransitions.Next((ReviewStage)999, ReviewAction.Submit));
        Expect<InvalidOperationException>(() => ReviewTransitions.Next(ReviewStage.Draft, (ReviewAction)999));
        Console.WriteLine($"State pattern checks: {checks}");
    }

    private static ReviewDocument At(ReviewStage stage)
    {
        var item = new ReviewDocument("본문");
        if (stage is ReviewStage.InReview or ReviewStage.Published) item.Submit();
        if (stage is ReviewStage.Published) item.Approve();
        return item;
    }

    private static void Execute(ReviewDocument document, ReviewAction action)
    {
        switch (action)
        {
            case ReviewAction.Submit: document.Submit(); break;
            case ReviewAction.Approve: document.Approve(); break;
            case ReviewAction.Reject: document.Reject("검토 의견"); break;
            default: throw new ArgumentOutOfRangeException(nameof(action));
        }
    }

    private static void Equal<T>(T expected, T actual)
    {
        if (!System.Collections.Generic.EqualityComparer<T>.Default.Equals(expected, actual))
            throw new Exception($"기댓값: {expected}, 실제값: {actual}");
        checks++;
    }

    private static void Expect<TException>(Action action) where TException : Exception
    {
        try { action(); }
        catch (TException) { checks++; return; }
        throw new Exception($"{typeof(TException).Name} 예외가 필요합니다.");
    }
}