public class TimeOffDocumentAdapter: IDisposable
    {
        protected DocX document;

        public TimeOffDocumentAdapter(DocX document)
        {
            this.document = document;
        }

        public void SetJobTitle(string value)
        {
            this.document.Paragraphs[2].ReplaceText(Placeholders.JobTitle, value);
        }

        public void SetPersonName(string value)
        {
            this.document.Paragraphs[3].ReplaceText(Placeholders.PersonName, value);
        }

        public void SetTimeOffPeriod(string value)
        {
            value = new InsertStringFormatter().Format(value);
            this.document.Paragraphs[6].ReplaceText(Placeholders.TimeOffPeriod, value);
        }

        public void SetReason(string value)
        {
            if (value == null)
            {
                this.document.Paragraphs[7].RemoveText(0);
                this.document.Paragraphs[7].Hide();
            }
            else
            {
                value = new InsertStringFormatter().Format(value);
                this.document.Paragraphs[7].ReplaceText(Placeholders.Reason, value);
            }
        }

        public void SetWorkingOff(string value)
        {
            if (value == null)
            {
                this.document.Paragraphs[8].RemoveText(0);
                this.document.Paragraphs[8].Hide();
            }
            else
            {
                value = new InsertStringFormatter().Format(value, firstLetter: FirstLetter.Upper);
                this.document.Paragraphs[8].ReplaceText(Placeholders.WorkingOff, value);
            }
        }

        public void SetSendingDay(string value)
        {
            this.document.Paragraphs[10].ReplaceText(Placeholders.SendingDay, value);
        }

        public void SaveAs(string name)
        {
            this.document.SaveAs(name);
        }

        public void Dispose()
        {
            document?.Dispose();
        }
    }

    public class TimeOffMessageAdapter
    {
        protected HtmlDocument Doc;

        public TimeOffMessageAdapter(HtmlDocument doc)
        {
            this.Doc = doc;
        }

        public void SetJobTitle(string value)
        {
            var jobTitle = Doc.GetElementbyId("signature_job-title");

            var signature = jobTitle.ParentNode;

            var replaced = jobTitle.OuterHtml.Replace(Placeholders.JobTitle, value);

            var newNode = HtmlNode.CreateNode(replaced);

            signature.ReplaceChild(newNode, jobTitle);
        }

        public void SetPersonName(string value)
        {

            var name = Doc.GetElementbyId("signature_name");

            var signature = name.ParentNode;

            var replaced = name.OuterHtml.Replace(Placeholders.PersonName, value);

            var newNode = HtmlNode.CreateNode(replaced);

            signature.ReplaceChild(newNode, name);
        }

        public void SetTimeOffPeriod(string value)
        {
            var period = Doc.GetElementbyId("time-off_period");

            var body = period.ParentNode;

            value = new InsertStringFormatter().Format(value);

            var replaced = period.OuterHtml.Replace(Placeholders.TimeOffPeriod, value);

            var newNode = HtmlNode.CreateNode(replaced);

            body.ReplaceChild(newNode, period);
        }

        public void SetReason(string value)
        {
            var reason = Doc.GetElementbyId("time-off_reason");

            var parent = reason.ParentNode;

            if (value == null)
            {
                parent.RemoveChild(reason);
            }
            else
            {
                value = new InsertStringFormatter().Format(value);

                var replaced = reason.OuterHtml.Replace(Placeholders.Reason, value);

                var newNode = HtmlNode.CreateNode(replaced);

                parent.ReplaceChild(newNode, reason);
            }
        }

        public void SetWorkingOff(string value)
        {
            var reason = Doc.GetElementbyId("time-off_working-off");

            var parent = reason.ParentNode;

            if (value == null)
            {
                parent.RemoveChild(reason);
            }
            else
            {
                value = new InsertStringFormatter().Format(value, firstLetter: FirstLetter.Upper);

                var replaced = reason.OuterHtml.Replace(Placeholders.WorkingOff, value);

                var newNode = HtmlNode.CreateNode(replaced);

                parent.ReplaceChild(newNode, reason);
            }
        }

        public void SaveAs(TextWriter writer)
        {
            this.Doc.Save(writer);
        }
    }

public abstract class Command
{
    protected readonly CancellationTokenSource CancellationToken;

    [JsonIgnore]
    public CommandContext Context { get; set; } = null!;

    protected long ChatId => Context.ChatId;

    protected string Message => Context.Message;

    protected Command()
    {
        CancellationToken = new CancellationTokenSource();
    }

    // Метод, который отрабатывает при отправке комманды
    public abstract Task Execute();

    /* Метод который вызывается, когда комманда болтается в сессии и ждет,
    что пользователь введет что-либо в ответ на запрос бота */
    public virtual Task<int> OnMessage()
    {
        return Task.FromResult(ExecuteDirection.RunNext);
    }

    // Метод, который проверяет, что то, что ввел в ответ пользователь — валидно
    public virtual Task ValidateMessage()
    {
        return Task.CompletedTask;
    }

    // Метод для перывания комманды
    public virtual Task Cancel()
    {
        this.CancellationToken.Cancel();

        return Task.CompletedTask;
    }

    // А об этом методе мы поговорим попозже:)
    protected void ForceComplete()
    {
        throw new ForceCompleteCommandException(this.GetType().Name);
    }
}

public class StartCommand: Command
{
    private readonly ILogger<StartCommand> _logger = LogPoint.GetLogger<StartCommand>();

    public const string Key = "/start";

    public override async Task Execute()
    {
        _logger.LogInformation($"{ChatId}: Started work");

        await this.Context.TelegramClient.SendMessage(
            ChatId, 
            "Добро пожаловать!\r\n" +
            "\r\n" +
            "Перед началом работы вам необходимо:\r\n" +
            "/registeruser – зарегистрироваться\r\n" +
            "/registermail – зарегистрировать рабочую почту");
    }
}

public abstract class StatedCommand: Command
{
    private ILogger<StatedCommand> _logger = LogPoint.GetLogger<StatedCommand>();

    [JsonProperty]
    protected CommandClip Clip;

    protected StatedCommand()
    {
        var states = this.ConfigureStates();
        this.Clip = new CommandClip(states);
    }

    public abstract List<Command> ConfigureStates();

    public override async Task Execute()
    {
        try
        {
            await Clip.Run(Context);

            if (Clip.IsCompleted)
            {
                await OnComplete();
            }
            else
            {
                await Context.SaveSession(this);
            }
        }
        catch (ForceCompleteCommandException e)
        {
            await this.OnForceComplete(e);
        }
    }

    public override async Task<int> OnMessage()
    {
        await this.Execute();
        return ExecuteDirection.RunNext;
    }

    public override async Task Cancel()
    {
        await base.Cancel();

        await Clip.Cancel(Context);
    }

    protected async Task OnComplete()
    {
        await Context.SessionStorage.DeleteSession(ChatId);
    }

    private async Task OnForceComplete(ForceCompleteCommandException e)
    {
        await this.OnComplete();
        _logger.LogWarning($"Сommand {e.CommandName} force completed");
    }
}

public class CommandClip
{
    private readonly ILogger<CommandClip> _logger = LogPoint.GetLogger<CommandClip>();

    [JsonProperty]
    private readonly Command[] _states;

    [JsonProperty]
    private int _runIndex = 0;

    public bool IsFinishedChain => _runIndex == _states.Length;

    private int LastIndex => _states.Length - 1;

    public bool IsAsymmetricCompleted
    {
        get
        {
            if (_runIndex != LastIndex - 1)
            {
                return false;
            }
            else
            {
                return _states[_runIndex + 1].GetType() == typeof(AssymetricCompleteCommand);
            }
        }
    }

    public bool IsCompleted => IsFinishedChain || IsAsymmetricCompleted;

    public int RunIndex => _runIndex;

    public CommandClip(IEnumerable<Command> states)
    {
        _states = states.ToArray();
    }

    public async Task Run(CommandContext context)
    {
        if (IsFinishedChain) return;

        var firstPartCommand = _states[_runIndex];

        try
        {
            var firstPartExecutor = new CommandExecutor(firstPartCommand, context);

            await firstPartExecutor.ValidateMessage();
            var increment = await firstPartExecutor.OnMessage();

            if (increment <= 0)
            {
                context.BackwardRedirect = true;
            }

            this.IncrementStep(increment);

            if (IsFinishedChain) return;

            var secondPartCommand = _states[_runIndex];
            var secondPartExecutor = new CommandExecutor(secondPartCommand, context);

            _logger.LogInformation($"{context.ChatId}: Start execute command {secondPartCommand.GetType().Name}");
            await secondPartExecutor.Execute();
        }
        catch (IncorrectFormatException e)
        {
            _logger.LogWarning(e, $"Incorrect format of command {firstPartCommand.GetType().Name}: \"{context.Message}\"");
        }
    }

    public Task Cancel(CommandContext context)
    {
        var state = _states[_runIndex];
        var executor = new CommandExecutor(state, context);

        return executor.Cancel();
    }

    private void IncrementStep(int value)
    {
        this._runIndex += value;
    }
}

public class TimeOffCommand: StatedCommand
{
    private ILogger<TimeOffCache> _logger = LogPoint.GetLogger<TimeOffCache>();

    public const string Key = "/timeoff";

    public override List<Command> ConfigureStates()
    {
        return new List<Command>()
        {
            new EmptyCommand(), 
            new EnterPeriodCommand(),
            new EnterReasonCommand(),
            new EnterWorkingOffCommand(),
            new CheckDocumentCommand(),
            new SetEmailsCommand(),
            new CheckEmailsCommand(),
            new SendDocumentCommand(),
            new AssymetricCompleteCommand(),
        };
    }

    public override async Task Execute()
    {
        try
        {
            await base.Execute();
        }
        catch (NonCompleteUserException e)
        {
            await HandleUserException(e);
            await OnComplete();

            this._logger.LogError(e, $"Command was completed by exception");
        }
    }

    private async Task HandleUserException(NonCompleteUserException e)
    {
        await new NonCompleteUserExceptionHandlerVisitor().Handle(e, ChatId, Context.TelegramClient);
    }
}