package gudusoft.gsqlparser.pp.print;

import gudusoft.gsqlparser.ETokenStatus;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.pp.output.OutputConfig;
import gudusoft.gsqlparser.pp.utils.SourceTokenNameConstant;

import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * the text print
 *
 * @author zhoujun
 *
 */
public class TextPrinter implements IPrinter
{

        private OutputStream out = System.out;

        private OutputConfig outputConfig = null;

        /*
         * (non-Javadoc)
         *
         * @see gudusoft.gsqlparser.pp.print.IPrinter#print(gudusoft.gsqlparser.
         * TSourceTokenList)
         */
        public void print( TSourceTokenList tl )
        {
                List<TSourceToken> flat = new ArrayList<TSourceToken>( tl.size( ) );
                flatten( tl, flat );
                boolean inNoFormat = false;
                for ( int i = 0; i < flat.size( ); i++ )
                {
                        TSourceToken t = flat.get( i );
                        if ( isComment( t ) )
                        {
                                String c = t.toString( ).toLowerCase( java.util.Locale.ROOT );
                                if ( c.contains( SourceTokenNameConstant.BEGIN_NO_FORMAT ) )
                                {
                                        inNoFormat = true;
                                }
                                else if ( c.contains( SourceTokenNameConstant.END_NO_FORMAT ) )
                                {
                                        inNoFormat = false;
                                }
                        }
                        // Trailing blanks before a line break are never part of a token
                        // (string literals and comments are single tokens), so dropping
                        // them cannot change any token's text. Without this, a whitespace
                        // token left behind a "--" comment became part of that comment
                        // when the output was lexed again, and many lines ended in blanks
                        // (PrettyScore TRAILING_WHITESPACE / COMMENTS_PRESERVED). A
                        // no-format zone is reproduced verbatim, blanks included.
                        if ( !inNoFormat && isWhitespaceToken( t ) )
                        {
                                // the first non-blank token after this one (blank tokens may come in runs)
                                int j = i + 1;
                                while ( j < flat.size( ) && isBlankToken( flat.get( j ) ) )
                                {
                                        j++;
                                }
                                TSourceToken next = j < flat.size( ) ? flat.get( j ) : null;
                                TSourceToken prev = i > 0 ? flat.get( i - 1 ) : null;
                                // keep one blank after a MySQL "$" delimiter: "END$" directly
                                // followed by a line break lexes as one identifier
                                boolean keepOne = prev != null && endsWithDollar( prev );
                                String text = t.toString( );
                                // blanks inside a merged whitespace token ("  \n    ") that sit
                                // before a line break
                                String stripped = stripBlanksBeforeLineBreaks( text, keepOne );
                                if ( isBlankToken( t ) && ( next == null || startsWithLineBreak( next ) ) )
                                {
                                        stripped = keepOne ? " " : "";
                                }
                                if ( !stripped.equals( text ) )
                                {
                                        if ( !stripped.isEmpty( ) )
                                        {
                                                printText( stripped );
                                        }
                                        continue;
                                }
                        }
                        print( t );
                }
        }

        /**
         * Expand tokensBefore / replaceToken / tokensAfter in print order,
         * skipping deleted tokens.
         */
        private static void flatten( TSourceTokenList tl, List<TSourceToken> out )
        {
                TSourceToken activeSplit = null;
                for ( int i = 0; i < tl.size( ); i++ )
                {
                        TSourceToken t = tl.get( i );
                        if ( t.tokenstatus == ETokenStatus.tsdeleted )
                        {
                                continue;
                        }
                        // A run of tokens the vendor tokenizer split from one source token
                        // (BigQuery `p.d.t`) is printed as that source token, once: the
                        // user's spelling is not the formatter's to change.
                        if ( t.splitFrom != null )
                        {
                                boolean first = activeSplit != t.splitFrom;
                                boolean last = true;
                                for ( int j = i + 1; j < tl.size( ); j++ )
                                {
                                        TSourceToken n = tl.get( j );
                                        if ( n.tokenstatus == ETokenStatus.tsdeleted )
                                        {
                                                continue;
                                        }
                                        last = n.splitFrom != t.splitFrom;
                                        break;
                                }
                                if ( first )
                                {
                                        activeSplit = t.splitFrom;
                                        if ( t.getTokensBefore( ) != null && t.getTokensBefore( ).size( ) > 0 )
                                        {
                                                flatten( t.getTokensBefore( ), out );
                                        }
                                        out.add( t.splitFrom );
                                }
                                if ( last && t.getTokensAfter( ) != null && t.getTokensAfter( ).size( ) > 0 )
                                {
                                        flatten( t.getTokensAfter( ), out );
                                }
                                continue;
                        }
                        activeSplit = null;
                        if ( t.getTokensBefore( ) != null
                                        && t.getTokensBefore( ).size( ) > 0 )
                        {
                                flatten( t.getTokensBefore( ), out );
                        }
                        if ( t.getReplaceToken( ) != null )
                        {
                                out.add( t.getReplaceToken( ) );
                        }
                        else
                        {
                                out.add( t );
                        }
                        if ( t.getTokensAfter( ) != null && t.getTokensAfter( ).size( ) > 0 )
                        {
                                flatten( t.getTokensAfter( ), out );
                        }
                }
        }

        /**
         * Drops the blanks (spaces, tabs) that sit directly before a line break ({@code \n} or {@code \r\n}),
         * leaving one blank when {@code keepOne}. The result is that of
         * {@code text.replaceAll("[ \t]+(\r?\n)", keepOne ? " $1" : "$1")}, in one linear pass: the regex
         * backtracks quadratically over a long run of blanks that no line break follows.
         */
        static String stripBlanksBeforeLineBreaks( String text, boolean keepOne )
        {
                StringBuilder out = null;
                int n = text.length( );
                int i = 0;
                while ( i < n )
                {
                        char c = text.charAt( i );
                        if ( c != ' ' && c != '\t' )
                        {
                                if ( out != null )
                                {
                                        out.append( c );
                                }
                                i++;
                                continue;
                        }
                        int end = i;
                        while ( end < n && ( text.charAt( end ) == ' ' || text.charAt( end ) == '\t' ) )
                        {
                                end++;
                        }
                        boolean beforeLineBreak = end < n && ( text.charAt( end ) == '\n'
                                        || ( text.charAt( end ) == '\r' && end + 1 < n && text.charAt( end + 1 ) == '\n' ) );
                        if ( beforeLineBreak )
                        {
                                if ( out == null )
                                {
                                        out = new StringBuilder( n ).append( text, 0, i );
                                }
                                if ( keepOne )
                                {
                                        out.append( ' ' );
                                }
                        }
                        else if ( out != null )
                        {
                                out.append( text, i, end );
                        }
                        i = end;
                }
                return out == null ? text : out.toString( );
        }

        /** Whitespace / return tokens, including formatter-made ones that carry no type. */
        private static boolean isWhitespaceToken( TSourceToken t )
        {
                if ( t.tokentype == ETokenType.ttwhitespace || t.tokentype == ETokenType.ttreturn )
                {
                        return true;
                }
                if ( t.tokentype != null )
                {
                        return false;
                }
                String s = t.toString( );
                if ( s == null || s.isEmpty( ) )
                {
                        return false;
                }
                for ( int i = 0; i < s.length( ); i++ )
                {
                        char c = s.charAt( i );
                        if ( c != ' ' && c != '\t' && c != '\n' && c != '\r' )
                        {
                                return false;
                        }
                }
                return true;
        }

        private void printText( String text )
        {
                try
                {
                        out.write( text.getBytes( ) );
                }
                catch ( IOException e )
                {
                        e.printStackTrace( );
                }
        }

        private static boolean isComment( TSourceToken t )
        {
                return t.tokentype == ETokenType.ttsimplecomment
                                || t.tokentype == ETokenType.ttbracketedcomment
                                || t.tokentype == ETokenType.ttCPPComment;
        }

        /**
         * A token made only of blanks (spaces / tabs), never a return; formatter-made
         * blanks may carry no type, and an empty placeholder token counts as blank.
         */
        private static boolean isBlankToken( TSourceToken t )
        {
                if ( t.tokentype != null && t.tokentype != ETokenType.ttwhitespace )
                {
                        return false;
                }
                String s = t.toString( );
                if ( s == null || s.isEmpty( ) )
                {
                        return true;
                }
                for ( int i = 0; i < s.length( ); i++ )
                {
                        char c = s.charAt( i );
                        if ( c != ' ' && c != '\t' )
                        {
                                return false;
                        }
                }
                return true;
        }

        /**
         * A token ending in "$" (MySQL delimiter, {@code END$}, PostgreSQL {@code $$}):
         * the blank after it is kept because "$" directly followed by a line break
         * fuses with the preceding word when the output is lexed again.
         */
        private static boolean endsWithDollar( TSourceToken t )
        {
                String s = t.toString( );
                return s != null && !s.isEmpty( ) && s.charAt( s.length( ) - 1 ) == '$';
        }

        private static boolean startsWithLineBreak( TSourceToken t )
        {
                if ( t.tokentype == ETokenType.ttreturn )
                {
                        return true;
                }
                String s = t.toString( );
                return s != null && !s.isEmpty( )
                                && ( s.charAt( 0 ) == '\n' || s.charAt( 0 ) == '\r' );
        }

        /*
         * (non-Javadoc)
         *
         * @see
         * gudusoft.gsqlparser.pp.print.IPrinter#print(gudusoft.gsqlparser.TSourceToken
         * )
         */
        public void print( TSourceToken t )
        {
                try
                {
                        if ( outputConfig != null )
                        {
                                out.write( outputConfig.renderHighlightingElement( t )
                                                .toString( )
                                                .getBytes( ) );
                        }
                        else
                        {
                                out.write( t.toString( ).getBytes( ) );
                        }
                }
                catch ( IOException e )
                {
                        // TODO Auto-generated catch block
                        e.printStackTrace( );
                }
        }

        public OutputStream getOut( )
        {
                return out;
        }

        public void setOut( OutputStream out )
        {
                this.out = out;
        }

        public void setOutputConfig( OutputConfig outputConfig )
        {
                this.outputConfig = outputConfig;
        }

}