package LatexIndent::Verbatim;

#	This program is free software: you can redistribute it and/or modify
#	it under the terms of the GNU General Public License as published by
#	the Free Software Foundation, either version 3 of the License, or
#	(at your option) any later version.
#
#	This program is distributed in the hope that it will be useful,
#	but WITHOUT ANY WARRANTY; without even the implied warranty of
#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#	GNU General Public License for more details.
#
#	See http://www.gnu.org/licenses/.
#
#	Chris Hughes, 2017-2025
#
#	For all communication, please visit: https://github.com/cmhughes/latexindent.pl
use strict;
use warnings;
use Data::Dumper;
use Exporter                     qw/import/;
use LatexIndent::Tokens          qw/%tokens/;
use LatexIndent::GetYamlSettings qw/%mainSetting/;
use LatexIndent::Switches        qw/$is_t_switch_active $is_tt_switch_active $is_m_switch_active/;
use LatexIndent::LogFile         qw/$logger/;
our @EXPORT_OK
    = qw/put_verbatim_back_in find_verbatim_environments find_noindent_block find_verbatim_commands find_verbatim_special verbatim_common_tasks %verbatimStorage/;
our @ISA = "LatexIndent::Document";    # class inheritance, Programming Perl, pg 321
our $verbatimCounter;
our %verbatimStorage;

sub find_noindent_block {
    my $self = shift;

    # noindent block
    $logger->trace('*Searching for NOINDENTBLOCK (see noIndentBlock)') if $is_t_switch_active;
    $logger->trace( Dumper( \%{ $mainSetting{noIndentBlock} } ) )      if ($is_tt_switch_active);
    while ( my ( $noIndentBlock, $yesno ) = each %{ $mainSetting{noIndentBlock} } ) {

        # integrity check on the field for noIndentBlock
        if ( ref($yesno) eq "HASH" ) {
            if ( defined ${$yesno}{lookForThis} and !${$yesno}{lookForThis} ) {
                $logger->trace(" *not* looking for $noIndentBlock as lookForThis: 0") if $is_t_switch_active;
                next;
            }
            if ( not defined ${$yesno}{name} ) {
                if ( not defined ${$yesno}{begin} ) {
                    $logger->trace(" *not* looking for $noIndentBlock as $noIndentBlock:begin not specified")
                        if $is_t_switch_active;
                    next;
                }
                elsif ( not defined ${$yesno}{end} ) {
                    $logger->trace(" *not* looking for $noIndentBlock as $noIndentBlock:end not specified")
                        if $is_t_switch_active;
                    next;
                }
            }
            elsif ( defined ${$yesno}{begin} or defined ${$yesno}{end} ) {
                $logger->trace(
                    " *not* looking for $noIndentBlock as $noIndentBlock:name specified with begin and/or end")
                    if $is_t_switch_active;
                next;
            }
        }
        elsif ( ref($yesno) ne "HASH" and !$yesno ) {
            $logger->trace(" *not* looking for $noIndentBlock as $noIndentBlock:$yesno") if $is_t_switch_active;
            next;
        }

        # if we've made it this far, then we're good to go
        my $noIndentRegExp;
        my $noIndentBlockObj;

        if ( ref($yesno) eq "HASH" ) {

            # default value of begin and end
            if ( defined ${$yesno}{name} and not defined ${$yesno}{begin} and not defined ${$yesno}{end} ) {
                ${$yesno}{begin} = "\\\\begin\\{(${$yesno}{name})\\}";
                ${$yesno}{end}   = "\\\\end\\{\\2\\}";
                $logger->trace("looking for regex based $noIndentBlock, name: ${$yesno}{name}") if $is_t_switch_active;
                $logger->trace("begin not specified for $noIndentBlock, setting default ${$yesno}{begin}")
                    if $is_t_switch_active;
                $logger->trace("end not specified for $noIndentBlock, setting default ${$yesno}{end}")
                    if $is_t_switch_active;
            }

            # default value of body
            if ( not defined ${$yesno}{body} ) {
                $logger->trace("looking for regex based $noIndentBlock, begin: ${$yesno}{begin}, end: ${$yesno}{end}")
                    if $is_t_switch_active;
                $logger->trace("body not specified for $noIndentBlock, setting default .*?") if $is_t_switch_active;
                ${$yesno}{body} = qr/.*?/sx;
            }
            else {
                $logger->trace("looking for regex based $noIndentBlock") if $is_t_switch_active;
                $logger->trace("begin: ${$yesno}{begin}")                if $is_t_switch_active;
                $logger->trace("body: ${$yesno}{body}")                  if $is_t_switch_active;
                $logger->trace("end: ${$yesno}{end}")                    if $is_t_switch_active;
            }

            $noIndentRegExp = qr/
                            (${$yesno}{begin})
                            (${$yesno}{body})
                            (${$yesno}{end})
                        /sx;
        }
        else {
            $logger->trace("looking for $noIndentBlock:$yesno noIndentBlock") if $is_t_switch_active;

            ( my $noIndentBlockSpec = $noIndentBlock ) =~ s/\*/\\*/sg;
            $noIndentRegExp = qr/
                            (
                                (?!<\\)
                                %
                                (?:\h|(?!<\\)%)*             # possible horizontal spaces
                                \\begin\{
                                        ($noIndentBlockSpec) # environment name captured into $2
                                       \}                    # % \begin{noindentblock} statement
                            )                                # begin statement captured into $1
                            (
                                .*?                          # non-greedy match (body) into $3
                            )
                            (
                                (?!<\\)
                                %                            # %
                                (?:\h|(?!<\\)%)*             # possible horizontal spaces
                                \\end\{\2\}                  # % \end{noindentblock} statement
                            )                                # end statement captured into $4
                        /sx;
        }
        while ( ${$self}{body} =~ m/$noIndentRegExp/sx ) {

            # create a new Verbatim object
            if ( ref($yesno) eq "HASH" and not defined ${$yesno}{name} ) {

                # user defined begin and end statements
                $noIndentBlockObj = LatexIndent::Verbatim->new(
                    begin                    => $1,
                    body                     => $2,
                    end                      => $3,
                    name                     => $noIndentBlock,
                    type                     => "noindentblock",
                    modifyLineBreaksYamlName => "verbatim",
                );
            }
            else {
                # specified by name (entry:1 or entry: name: regex)
                $noIndentBlockObj = LatexIndent::Verbatim->new(
                    begin                    => $1,
                    body                     => $3,
                    end                      => $4,
                    name                     => $2,
                    type                     => "noindentblock",
                    modifyLineBreaksYamlName => "verbatim",
                );
            }

            # give unique id
            $noIndentBlockObj->create_unique_id;

            # verbatim children go in special hash
            $verbatimStorage{ ${$noIndentBlockObj}{id} } = $noIndentBlockObj;

            # log file output
            $logger->trace("NOINDENTBLOCK found: ${$noIndentBlockObj}{name}") if $is_t_switch_active;

            # remove the environment block, and replace with unique ID
            ${$self}{body} =~ s/$noIndentRegExp/${$noIndentBlockObj}{id}/sx;

            $logger->trace("replaced with ID: ${$noIndentBlockObj}{id}") if $is_t_switch_active;

            # possible decoration in log file
            $logger->trace( ${ $mainSetting{logFilePreferences} }{showDecorationFinishCodeBlockTrace} )
                if ${ $mainSetting{logFilePreferences} }{showDecorationFinishCodeBlockTrace};
        }
    }
    return;
}

sub find_verbatim_environments {
    my $self = shift;

    # verbatim environments
    $logger->trace('*Searching for VERBATIM environments (see verbatimEnvironments)') if $is_t_switch_active;
    $logger->trace( Dumper( \%{ $mainSetting{verbatimEnvironments} } ) )              if ($is_tt_switch_active);
    while ( my ( $verbEnv, $yesno ) = each %{ $mainSetting{verbatimEnvironments} } ) {
        my $verbEnvSpec;

        # integrity check on the field for noIndentBlock
        if ( ref($yesno) eq "HASH" ) {
            if ( defined ${$yesno}{lookForThis} and !${$yesno}{lookForThis} ) {
                $logger->trace(" *not* looking for $verbEnv as lookForThis: 0") if $is_t_switch_active;
                next;
            }
            elsif ( not defined ${$yesno}{name} ) {
                $logger->trace(" *not* looking for $verbEnv as $verbEnv:name not specified") if $is_t_switch_active;
                next;
            }
            else {
                $logger->trace("looking for VERBATIM-environments $verbEnv, name: ${$yesno}{name}")
                    if $is_t_switch_active;
                $verbEnvSpec = ${$yesno}{name};
            }
        }
        elsif ( ref($yesno) ne "HASH" and $yesno ) {
            $logger->trace("looking for $verbEnv:$yesno environments") if $is_t_switch_active;
            ( $verbEnvSpec = $verbEnv ) =~ s/\*/\\*/sg;
        }
        else {
            $logger->trace(" *not* looking for $verbEnv as $verbEnv:$yesno") if $is_t_switch_active;
            next;
        }

        # if we've made it this far, then we're good to go
        my $verbatimRegExp = qr/
                        (
                        \\begin\{
                                ($verbEnvSpec) # environment name captured into $2
                               \}              # \begin{<something>} statement captured into $1
                        )
                        (
                            .*?                # non-greedy match (body) into $3
                        )                      # any character, but not \\begin
                        (
                        \\end\{\2\}            # \end{<something>} statement captured into $4
                        )
                        (\h*)?                 # possibly followed by horizontal space
                        (\R\s*)?               # possibly followed by a line break
                    /sx;

        while ( ${$self}{body} =~ m/$verbatimRegExp/sx ) {

            # create a new Verbatim object
            my $verbatimBlock = LatexIndent::Verbatim->new(
                begin                    => $1,
                body                     => $3,
                end                      => $4,
                name                     => $2,
                type                     => "environment",
                modifyLineBreaksYamlName => "verbatim",
                linebreaksAtEnd          => { end => $6 ? $6 : q(), },
                horizontalTrailingSpace  => $5 ? $5 : q(),
                aliases                  => {

                    # begin statements
                    BeginStartsOnOwnLine => "VerbatimBeginStartsOnOwnLine",

                    # after end statements
                    EndFinishesWithLineBreak => "VerbatimEndFinishesWithLineBreak",
                },
            );

            # log file output
            $logger->trace("*VERBATIM environment found: ${$verbatimBlock}{name}") if $is_t_switch_active;

            # there are common tasks for each of the verbatim objects
            $verbatimBlock->verbatim_common_tasks;

            # verbatim children go in special hash
            $verbatimStorage{ ${$verbatimBlock}{id} } = $verbatimBlock;

            # remove the environment block, and replace with unique ID
            ${$self}{body} =~ s/$verbatimRegExp/${$verbatimBlock}{replacementText}/sx;

            $logger->trace("replaced with ID: ${$verbatimBlock}{id}") if $is_t_switch_active;

            # possible decoration in log file
            $logger->trace( ${ $mainSetting{logFilePreferences} }{showDecorationFinishCodeBlockTrace} )
                if ${ $mainSetting{logFilePreferences} }{showDecorationFinishCodeBlockTrace};
        }
    }
    return;
}

sub find_verbatim_commands {
    my $self = shift;

    # verbatim commands need to be treated separately to verbatim environments;
    # note that, for example, we could quite reasonably have \lstinline!%!, which
    # would need to be found *before* trailing comments have been removed. Similarly,
    # verbatim commands need to be put back in *after* trailing comments have been put
    # back in
    $logger->trace('*Searching for VERBATIM commands (see verbatimCommands)') if $is_t_switch_active;
    $logger->trace( Dumper( \%{ $mainSetting{verbatimCommands} } ) )          if ($is_tt_switch_active);
    while ( my ( $verbCommand, $yesno ) = each %{ $mainSetting{verbatimCommands} } ) {
        my $verbCommandSpec;

        # integrity check on the field for noIndentBlock
        if ( ref($yesno) eq "HASH" ) {
            if ( defined ${$yesno}{lookForThis} and !${$yesno}{lookForThis} ) {
                $logger->trace(" *not* looking for $verbCommand as lookForThis: 0") if $is_t_switch_active;
                next;
            }
            elsif ( not defined ${$yesno}{name} ) {
                $logger->trace(" *not* looking for $verbCommand as $verbCommand:name not specified")
                    if $is_t_switch_active;
                next;
            }
            else {
                $logger->trace("looking for regex based VERBATIM-commands $verbCommand, name: ${$yesno}{name}")
                    if $is_t_switch_active;
                $verbCommandSpec = ${$yesno}{name};
            }
        }
        elsif ( ref($yesno) ne "HASH" and $yesno ) {
            $logger->trace("looking for $verbCommand:$yesno Commands") if $is_t_switch_active;
            $verbCommandSpec = $verbCommand;
        }
        else {
            $logger->trace("*not* looking for $verbCommand as $verbCommand:$yesno") if $is_t_switch_active;
            next;
        }

        # if we've made it this far, then we're good to go
        my $verbatimRegExp = qr/
                        (
                            \\($verbCommandSpec) # name of command into $2
                            \h*
                        )
                        (
                            \[
                                (?:
                                    (?!
                                        (?:(?<!\\)\[) 
                                    ).
                                )*?     # not including [, but \[ ok
                            (?<!\\)     # not immediately pre-ceeded by \
                            \]          # [optional arguments]
                            \h*
                        )?              # opt arg into $3
                        (
                            .
                        )               # delimiter into $4
                        (
                            .*?
                        )               # body into $5
                        \4
                        (\h*)?          # possibly followed by horizontal space
                        (\R)?           # possibly followed by a line break 
                    /mx;

        while ( ${$self}{body} =~ m/$verbatimRegExp/ ) {

            # create a new Verbatim object
            my $verbatimCommand = LatexIndent::Verbatim->new(
                begin                    => $1 . ( $3 ? $3 : q() ) . $4,
                body                     => $5,
                end                      => $4,
                name                     => $2,
                type                     => "command",
                modifyLineBreaksYamlName => "verbatim",
                linebreaksAtEnd          => { end => $7 ? $7 : q(), },
                horizontalTrailingSpace  => $6 ? $6 : q(),
                aliases                  => {

                    # begin statements
                    BeginStartsOnOwnLine => "VerbatimBeginStartsOnOwnLine",

                    # after end statements
                    EndFinishesWithLineBreak => "VerbatimEndFinishesWithLineBreak",
                },
                optArg => $3 ? $3 : q(),
            );

            # there are common tasks for each of the verbatim objects
            $verbatimCommand->verbatim_common_tasks;

            # output, if desired
            $logger->trace( Dumper($verbatimCommand), 'ttrace' ) if ($is_tt_switch_active);

            # check for nested verbatim commands
            if ( ${$verbatimCommand}{body} =~ m/($tokens{verbatimInline}\d+$tokens{endOfToken})/s ) {
                my $verbatimNestedID = $1;
                my $verbatimBody
                    = ${ $verbatimStorage{$verbatimNestedID} }{begin}
                    . ${ $verbatimStorage{$verbatimNestedID} }{body}
                    . ${ $verbatimStorage{$verbatimNestedID} }{end};
                ${$verbatimCommand}{body} =~ s/$verbatimNestedID/$verbatimBody/s;
                delete $verbatimStorage{$verbatimNestedID};
            }

            # verbatim children go in special hash
            $verbatimStorage{ ${$verbatimCommand}{id} } = $verbatimCommand;

            # log file output
            $logger->trace("*VERBATIM command found: ${$verbatimCommand}{name}") if $is_t_switch_active;

            # remove the environment block, and replace with unique ID
            ${$self}{body} =~ s/$verbatimRegExp/${$verbatimCommand}{replacementText}/sx;

            $logger->trace("replaced with ID: ${$verbatimCommand}{id}") if $is_t_switch_active;
        }
    }
    return;

}

sub find_verbatim_special {
    my $self = shift;

    # loop through specialBeginEnd
    foreach ( @{ $mainSetting{specialBeginEnd} } ) {

        my $specialName = ${$_}{name};

        # only classify special Verbatim if lookForThis is 'verbatim'
        if ( ${$_}{lookForThis} =~ m/v/s and ${$_}{lookForThis} eq 'verbatim' ) {
            $logger->trace('*Searching for VERBATIM special (see specialBeginEnd)') if $is_t_switch_active;

            my $verbatimRegExp = qr/
                            (
                                ${$_}{begin}
                            )
                            (
                                .*?
                            )                    
                            (
                                ${$_}{end}
                            )                    
                            (\h*)?                    # possibly followed by horizontal space
                            (\R)?                     # possibly followed by a line break 
                        /sx;

            while ( ${$self}{body} =~ m/$verbatimRegExp/sx ) {

                # create a new Verbatim object
                my $verbatimBlock = LatexIndent::Verbatim->new(
                    begin                    => $1,
                    body                     => $2,
                    end                      => $3,
                    name                     => $specialName,
                    modifyLineBreaksYamlName => "specialBeginEnd",
                    linebreaksAtEnd          => { end => $5 ? $5 : q(), },
                    horizontalTrailingSpace  => $4 ? $4 : q(),
                    type                     => "special",
                    aliases                  => {

                        # begin statements
                        BeginStartsOnOwnLine => "SpecialBeginStartsOnOwnLine",

                        # after end statements
                        EndFinishesWithLineBreak => "SpecialEndFinishesWithLineBreak",
                    },
                );

                # there are common tasks for each of the verbatim objects
                $verbatimBlock->verbatim_common_tasks;

                # verbatim children go in special hash
                $verbatimStorage{ ${$verbatimBlock}{id} } = $verbatimBlock;

                # log file output
                $logger->trace("*VERBATIM special found: $specialName") if $is_t_switch_active;

                # remove the special block, and replace with unique ID
                ${$self}{body} =~ s/$verbatimRegExp/${$verbatimBlock}{replacementText}/sx;

                $logger->trace("replaced with ID: ${$verbatimBlock}{id}") if $is_t_switch_active;

                # possible decoration in log file
                $logger->trace( ${ $mainSetting{logFilePreferences} }{showDecorationFinishCodeBlockTrace} )
                    if ${ $mainSetting{logFilePreferences} }{showDecorationFinishCodeBlockTrace};
            }
            ${$_}{lookForThis} = 0;
        }
    }

    # remove verbatim elements from specialBeginEnd
    my @specialBeginEndTrimmed;
    foreach ( @{ $mainSetting{specialBeginEnd} } ) {
        push( @specialBeginEndTrimmed, $_ ) unless ( ${$_}{lookForThis} == 0 );
    }
    $logger->trace("*specialBeginEnd removing any elements with lookForThis: 0") if $is_t_switch_active;
    @{ $mainSetting{specialBeginEnd} } = @specialBeginEndTrimmed;

    $logger->trace("*Verbatim storage:")          if $is_tt_switch_active;
    $logger->trace( Dumper( \%verbatimStorage ) ) if $is_tt_switch_active;
}

sub put_verbatim_back_in {
    my $self  = shift;
    my %input = @_;

    my $verbatimCount = 0;
    my $toMatch       = q();
    if ( $input{match} eq "everything-except-commands" ) {
        $toMatch = "noindentblockenvironmentspeciallinesprotectpreamble";
    }
    elsif ( $input{match} eq "preamble" ) {
        $toMatch = "preamble";
    }
    else {
        $toMatch = "command";
    }

    # count the number of non-command verbatim objects
    while ( my ( $key, $child ) = each %verbatimStorage ) {
        ${$child}{type} = "environment" if !( defined ${$child}{type} );
        $verbatimCount++                if ( $toMatch =~ m/${$child}{type}/ );
    }

    return unless ( $verbatimCount > 0 );

    # search for environments/commands
    $logger->trace('*Putting verbatim back in') if $is_t_switch_active;
    $logger->trace('pre-processed body:')       if $is_tt_switch_active;
    $logger->trace( ${$self}{body} )            if ($is_tt_switch_active);

    # loop through document children hash
    my $verbatimFound = 0;
    while ( $verbatimFound < $verbatimCount ) {
        while ( my ( $verbatimID, $child ) = each %verbatimStorage ) {
            if ( $toMatch =~ m/${$child}{type}/ ) {
                if ( ${$self}{body} =~ m/$verbatimID/m ) {

                    # possibly remove trailing line break
                    if (    $is_m_switch_active
                        and defined ${$child}{EndFinishesWithLineBreak}
                        and ${$child}{EndFinishesWithLineBreak} == -1
                        and ${$self}{body} =~ m/$verbatimID\h*\R/s )
                    {
                        $logger->trace("m-switch active, removing trailing line breaks from ${$child}{name}")
                            if $is_t_switch_active;
                        ${$self}{body} =~ s/$verbatimID(\h*)?(\R|\h)*/$verbatimID /s;
                    }

                    # line protection mode can allow line breaks to be removed
                    # at end of verbatim; these need to be added back in
                    #
                    # see
                    #
                    #   test-cases/line-switch-test-cases/environments-simple-nested-mod13.tex
                    #
                    if ( ${$child}{type} eq "linesprotect" ) {

                        # remove leading space ahead of verbatim ID
                        ${$self}{body} =~ s/^\h*$verbatimID/$verbatimID/m;

                        if ( $is_m_switch_active and ${$self}{body} =~ m/$verbatimID\h*\S/s ) {
                            ${$self}{body} =~ s/$verbatimID\h*(\S)/$verbatimID\n$1/s;
                        }
                    }

                    # replace ids with body
                    ${$self}{body} =~ s/$verbatimID/${$child}{begin}${$child}{body}${$child}{end}/s;

                    # log file info
                    $logger->trace('Body now looks like:')     if $is_tt_switch_active;
                    $logger->trace( ${$self}{body}, 'ttrace' ) if ($is_tt_switch_active);

                    # delete the child so it won't be operated upon again
                    delete $verbatimStorage{$verbatimID};
                    $verbatimFound++;
                }
                elsif ( $is_m_switch_active
                    and ${ $mainSetting{modifyLineBreaks}{textWrapOptions} }{columns} > 1
                    and ${ $mainSetting{modifyLineBreaks}{textWrapOptions} }{huge} ne "overflow"
                    and ${$self}{body} !~ m/${$child}{id}/ )
                {
                    $logger->trace(
                        "$verbatimID not found in body using /m matching, it may have been split across line (see modifyLineBreaks: textWrapOptions)"
                    ) if ($is_t_switch_active);

                    # search for a version of the verbatim ID that may have line breaks
                    my $verbatimIDwithLineBreaks       = join( "\\R?", split( //, $verbatimID ) );
                    my $verbatimIDwithLineBreaksRegExp = qr/$verbatimIDwithLineBreaks/s;

                    # replace the line-broken verbatim ID with a non-broken verbatim ID
                    ${$self}{body} =~ s/$verbatimIDwithLineBreaksRegExp/${$child}{id}/s;

                    # note: we do *not* label this as found, as we need to go back through
                    #       and search for the newly modified ID
                }
            }

            # logfile info
            $logger->trace('*Post-processed body:') if $is_tt_switch_active;
            $logger->trace( ${$self}{body} )        if ($is_tt_switch_active);
        }
    }
    return;
}

sub verbatim_common_tasks {

    my $self = shift;

    # get yaml settings
    $self->yaml_modify_line_breaks_settings if $is_m_switch_active;

    # give unique id
    $self->create_unique_id;

    # the replacement text can be just the ID, but the ID might have a line break at the end of it
    ${$self}{replacementText} = ${$self}{id};

    # the above regexp, when used below, will remove the trailing linebreak in ${$self}{linebreaksAtEnd}{end}
    if ( defined ${$self}{horizontalTrailingSpace} ) {
        unless ( $is_m_switch_active
            and defined ${$self}{EndFinishesWithLineBreak}
            and ${$self}{EndFinishesWithLineBreak} == 2 )
        {
            ${$self}{replacementText} .= ${$self}{horizontalTrailingSpace};
        }
    }

    if ( !$is_m_switch_active ) {
        ${$self}{replacementText} =~ s/\s*$//s;
        ${$self}{replacementText} .= ${$self}{horizontalTrailingSpace} . ${$self}{linebreaksAtEnd}{end};
    }

    # modify line breaks end statements
    $self->_mlb_end_starts_on_own_line
        if ( $is_m_switch_active and defined ${$self}{EndStartsOnOwnLine} and ${$self}{EndStartsOnOwnLine} != 0 );

    # VerbatimEndFinishesWithLineBreak
    if (    $is_m_switch_active
        and defined ${$self}{EndFinishesWithLineBreak}
        and ${$self}{EndFinishesWithLineBreak} != 0 )
    {
        ${$self}{originalEnd} = ${$self}{end};
        $self->_mlb_end_finishes_with_line_break;

        # check if end statement has been modified
        if ( ${$self}{originalEnd} ne ${$self}{end} ) {
            $logger->trace(
                "taking comments/linebreak stuff from after ${$self}{originalEnd}, appending to replacement ID (VerbatimEndFinishesWithLineBreak == ${$self}{EndFinishesWithLineBreak})"
            );
            ${$self}{end} =~ s/\Q${$self}{originalEnd}\E(.*)//s;
            my $mSwitchTokens = $1;
            ${$self}{end} = ${$self}{originalEnd};
            ${$self}{replacementText} =~ s/\s*$//s;
            ${$self}{replacementText} .= $mSwitchTokens;
        }
    }

    if (    $is_m_switch_active
        and defined ${$self}{EndFinishesWithLineBreak}
        and ${$self}{EndFinishesWithLineBreak} == 0 )
    {
        ${$self}{replacementText} =~ s/\s*$//s;
        ${$self}{replacementText} .= ${$self}{horizontalTrailingSpace} . ${$self}{linebreaksAtEnd}{end};
        ${$self}{linebreaksAtEnd}{end} = q();
        ${$self}{horizontalTrailingSpace} = q();
    }

}

sub create_unique_id {
    my $self = shift;

    $verbatimCounter++;
    ${$self}{id}
        = ( ${$self}{type} eq 'command' ? $tokens{verbatimInline} : $tokens{verbatim} )
        . $verbatimCounter
        . $tokens{endOfToken};
    return;
}

sub yaml_get_textwrap_removeparagraphline_breaks {
    my $self = shift;
    $logger->trace("No text wrap or remove paragraph line breaks for verbatim code blocks, ${$self}{name}")
        if ${ $mainSetting{logFilePreferences} }{showDecorationFinishCodeBlockTrace};
}

1;
