package gudusoft.gsqlparser.pp.utils;

import gudusoft.gsqlparser.ETokenStatus;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.pp.logger.PPLogger;
import gudusoft.gsqlparser.pp.para.GFmtOpt;

/**
 * the helper class used for operating the source token
 * 
 * @author zhoujun
 * 
 */
public class SourceTokenOperator
{

        public static int removeWhitespaceBackward( GFmtOpt opt,
                        TSourceTokenList list, int end )
        {
                if ( end == 0 )
                {
                        return 0;
                }

                StringBuilder buf = new StringBuilder( );
                buf.append( "removeWhitespaceAndReturnFromEnd:\ntargetToken:" )
                                .append(list.get(end).getAstext())
                                .append( " newToken:" )
                                .append( list.get(end).getAstext().replaceAll( "\\n", "\\\\n" ) )
                                .append( "(type:" )
                                .append( list.get( end ).tokentype )
                                .append( ")" );
                int deleteWhitespaceCount = 0;
                // int deleteReturn = 0;

                int pos = end - 1;

                // remove all white space before end item
                TSourceToken token = list.get( pos );
                while ( token.tokentype == ETokenType.ttwhitespace )
                {

                        if ( token.tokentype == ETokenType.ttwhitespace )
                        {
                                deleteWhitespaceCount++;
                        }

                        if ( opt.opearateSourceToken )
                        {
                                token.setReplaceToken( SourceTokenConstant.EMPTY );
                        }

                        pos--;
                        if ( pos >= 0 )
                        {
                                token = token.container.get( pos );
                        }
                        else
                        {
                                break;
                        }
                }

                if ( token.tokentype == ETokenType.ttreturn )
                {
                        StringBuilder b = new StringBuilder( );
                        for (int i = 0; i < token.getAstext().length( ); i++ )
                        {
                                char c = token.getAstext().charAt( i );
                                if ( c != ' ' )
                                {
                                        b.append( c );
                                }
                        }
                        token.setAstext(b.toString( ));
                }

                buf.append( "\nDeleteWhiteSpace:" ).append( deleteWhitespaceCount );
                PPLogger.info( 2, buf.toString( ), null );

                return pos;
        }

        /**
         * remove the white space and the return token from the end
         * 
         * @param list
         * @param end
         * @return the pos which is not white space and return token in the source
         *         token list
         */
        public static int removeWhitespaceAndReturnFromEnd( GFmtOpt opt,
                        TSourceTokenList list, int end )
        {
                if ( end == 0 )
                {
                        return 0;
                }

                StringBuilder buf = new StringBuilder( );
                buf.append( "removeWhitespaceAndReturnFromEnd:\ntargetToken:" )
                                .append(list.get(end).getAstext())
                                .append( " newToken:" )
                                .append( list.get(end).getAstext().replaceAll( "\\n", "\\\\n" ) )
                                .append( "(type:" )
                                .append( list.get( end ).tokentype )
                                .append( ")" );
                int deleteWhitespaceCount = 0;
                int deleteReturn = 0;

                int pos = end - 1;

                // remove all white space before end item
                TSourceToken token = list.get( pos );
                while ( token.tokentype == ETokenType.ttwhitespace
                                || token.tokentype == ETokenType.ttreturn )
                {
                        if ( token.tokentype == ETokenType.ttwhitespace )
                        {
                                deleteWhitespaceCount++;
                        }

                        if ( token.tokentype == ETokenType.ttreturn )
                        {
                                deleteReturn++;
                        }

                        if ( opt.opearateSourceToken )
                        {
                                token.setReplaceToken( SourceTokenConstant.EMPTY );
                        }

                        pos--;
                        if ( pos >= 0 )
                        {
                                token = token.container.get( pos );
                        }
                        else
                        {
                                break;
                        }
                }

                buf.append( "\nDeleteWhiteSpace:" )
                                .append( deleteWhitespaceCount )
                                .append( ", DeleteReturn:" )
                                .append( deleteReturn );
                PPLogger.info( 2, buf.toString( ), null );

                return pos;
        }

        /**
         * remove the white space and the return token from the end
         * 
         * @param token
         * @return the pos which is not whitespace and return token in the source
         *         token list
         */
        public static int removeWhitespaceAndReturnFromEnd( GFmtOpt opt,
                        TSourceToken token )
        {
                if ( token == null )
                {
                        return -1;
                }
                return removeWhitespaceAndReturnFromEnd( opt,
                                token.container,
                                token.posinlist );
        }

        /**
         * remove the white space and the return token before this token and after
         * this token
         * 
         * @param opt
         * @param token
         */
        public static void removeWhitespaceAndReturnFormBeforeAndAfter(
                        GFmtOpt opt, TSourceToken token )
        {
                if ( token == null )
                {
                        return;
                }
                removeWhitespaceAndReturnFromEnd( opt, token );
                removeWhitespaceAndReturnFromStart( opt,
                                token.container,
                                token.posinlist + 1 );

        }

        /**
         * remove the white space and the return token
         * 
         * @param list
         * @param start
         * @param end
         */
        public static void removeWhitespaceAndReturn( GFmtOpt opt,
                        TSourceTokenList list, int start, int end )
        {
                StringBuilder buf = new StringBuilder( );
                buf.append( "removeWhitespaceAndReturn:\ntargetToken:" )
                                .append(list.get(end).getAstext())
                                .append( " newToken:" )
                                .append( list.get(end).getAstext().replaceAll( "\\n", "\\\\n" ) )
                                .append( "(type:" )
                                .append( list.get( end ).tokentype )
                                .append( ")" );
                int deleteWhitespaceCount = 0;
                int deleteReturn = 0;

                for ( int i = start; i < end; i++ )
                {
                        if ( i < 0 || i > list.size( ) )
                        {
                                return;
                        }
                        TSourceToken token = list.get( i );
                        if ( token.tokentype == ETokenType.ttwhitespace
                                        || token.tokentype == ETokenType.ttreturn )
                        {

                                if ( token.tokentype == ETokenType.ttwhitespace )
                                {
                                        deleteWhitespaceCount++;
                                }

                                if ( token.tokentype == ETokenType.ttreturn )
                                {
                                        deleteReturn++;
                                }
                                if ( opt.opearateSourceToken )
                                {
                                        token.setReplaceToken( SourceTokenConstant.EMPTY );
                                }
                        }
                }

                buf.append( "\nDeleteWhiteSpace:" )
                                .append( deleteWhitespaceCount )
                                .append( ", DeleteReturn:" )
                                .append( deleteReturn );
                PPLogger.info( 2, buf.toString( ), null );

        }

        /**
         * remove the white space and the return token from the end
         * 
         * @param list
         */
        public static int removeWhitespaceAndReturnFromStart( GFmtOpt opt,
                        TSourceTokenList list, int startPos )
        {
                StringBuilder buf = new StringBuilder( );
                if ( list.size( ) <= startPos )
                {
                        return list.size( ) - 1;
                }
                buf.append( "removeWhitespaceAndReturnFromStart:\ntargetToken:" )
                                .append(list.get(startPos).getAstext())
                                .append( " newToken:" )
                                .append( list.get(startPos).getAstext().replaceAll( "\\n", "\\\\n" ) )
                                .append( "(type:" )
                                .append( list.get( startPos ).tokentype )
                                .append( ")" );
                int deleteWhitespaceCount = 0;
                int deleteReturn = 0;

                int pos = startPos;
                // remove all white space before end item
                TSourceToken token = list.get( pos );
                while ( token.tokentype == ETokenType.ttwhitespace
                                || token.tokentype == ETokenType.ttreturn )
                {
                        if ( token.tokentype == ETokenType.ttwhitespace )
                        {
                                deleteWhitespaceCount++;
                        }

                        if ( token.tokentype == ETokenType.ttreturn )
                        {
                                deleteReturn++;
                        }

                        if ( opt.opearateSourceToken )
                        {
                                token.setReplaceToken( SourceTokenConstant.EMPTY );
                        }

                        pos++;
                        if ( pos < list.size( ) )
                        {
                                token = token.container.get( pos );
                        }
                        else
                        {
                                break;
                        }
                }

                buf.append( "\nDeleteWhiteSpace:" )
                                .append( deleteWhitespaceCount )
                                .append( ", DeleteReturn:" )
                                .append( deleteReturn );
                PPLogger.info( 2, buf.toString( ), null );

                return pos;
        }

        /**
         * calculate the text length for all virtual token (which are call before
         * tokens, after tokens and replace token)
         * 
         * @param list
         * @param start
         * @param end
         * @return
         */
        public static int textLengthVT( TSourceTokenList list, int start, int end )
        {
                int total = 0;
                for ( int i = start; i < end; i++ )
                {
                        TSourceToken token = list.get( i );

                        if ( token.getTokensBefore( ).size( ) > 0 )
                        {
                                total += textLengthVT( token.getTokensBefore( ),
                                                0,
                                                token.getTokensBefore( ).size( ) );
                        }
                        if ( token.getReplaceToken( ) != null )
                        {
                                total += ( token.getReplaceToken().getAstext() != null ? token.getReplaceToken().getAstext().length( )
                                                : 0 );
                        }
                        else
                        {
                                total += ( token.getAstext() != null ? token.getAstext().length( ) : 0 );
                        }
                        if ( token.getTokensAfter( ).size( ) > 0 )
                        {
                                total += textLengthVT( token.getTokensAfter( ),
                                                0,
                                                token.getTokensAfter( ).size( ) );
                        }
                }

                return total;
        }

        /**
         * calcaulate the text length from a given position to the line start. VT is
         * the abbr for "virtual token" (which contains before tokens, after tokens
         * and replace token)
         * 
         * @param list
         * @param pos
         * @return
         */
        public static int curColumnNumberVT( TSourceTokenList list, int pos )
        {

                int total = 0;

                for ( int i = pos; i >= 0; i-- )
                {
                        TSourceToken token = list.get( i );
                        
                        if(token.tokenstatus == ETokenStatus.tsdeleted) {
                                continue;
                        } 

                        // the after tokens in the last sourceToken should not calculated.
                        if ( i != pos && token.getTokensAfter( ).size( ) > 0 )
                        {
                                for ( int j = token.getTokensAfter( ).size( ) - 1; j >= 0; j-- )
                                {
                                        TSourceToken after = token.getTokensAfter( ).get( j );
                                        if ( after.tokentype != ETokenType.ttreturn )
                                        {
                                                total += ( after.getAstext() != null ? after.getAstext().length( )
                                                                : 0 );
                                        }
                                        else
                                        {
                                                return total;
                                        }
                                }
                        }
                        if ( i != pos )
                        {
                                if ( token.getReplaceToken( ) != null )
                                {
                                        if ( token.getReplaceToken( ).tokentype != ETokenType.ttreturn )
                                        {
                                                total += ( token.getReplaceToken().getAstext() != null ? token.getReplaceToken().getAstext().length( )
                                                                : 0 );
                                        }
                                        else
                                        {
                                                return total;
                                        }
                                }
                                else
                                {
                                        if ( token.tokentype != ETokenType.ttreturn )
                                        {
                                                if(token.tokentype == ETokenType.ttsimplecomment) {
                                                        if(token.nextToken()!=null &&
                                                                        token.nextToken().getAstext() !=null &&
                                                                        token.nextToken().getAstext().trim().length() == 0) {
                                                                total -= token.nextToken().getAstext().length( );
                                                        }
                                                        continue;
                                                }
                                                if(isOracleHint(token)) {
                                                        if(token.nextToken()!=null &&
                                                                        token.nextToken().getAstext() !=null &&
                                                                        token.nextToken().getAstext().trim().length() == 0) {
                                                                total -= token.nextToken().getAstext().length( );
                                                        }
                                                        continue;
                                                }
                                                total += ( token.getAstext() != null ? token.getAstext().length( )
                                                                : 0 );
                                        }
                                        else
                                        {
                                                return total;
                                        }
                                }
                        }

                        if ( token.getTokensBefore( ).size( ) > 0 )
                        {
                                for ( int j = token.getTokensBefore( ).size( ) - 1; j >= 0; j-- )
                                {
                                        TSourceToken before = token.getTokensBefore( ).get( j );
                                        if ( before.tokentype != ETokenType.ttreturn )
                                        {
                                                total += ( before.getAstext() != null ? before.getAstext().length( )
                                                                : 0 );
                                        }
                                        else
                                        {
                                                return total;
                                        }
                                }
                        }
                }

                return total;
        }

        private static boolean isOracleHint(TSourceToken token) {
                return token!=null && token.getAstext() !=null && token.getAstext().startsWith("/*+");
        }

        /**
         * calcaulate the text length from a given position to the line start. VT is
         * the abbr for "virtual token" (which contains before tokens, after tokens
         * and replace token)
         * 
         * @param token
         * @return
         */
        public static int curColumnNumberVT( TSourceToken token )
        {
                return curColumnNumberVT( token.container, token.posinlist );
        }

        /**
         * calculate the current indent length VT is the abbr for "virtual token"
         * (which contains before tokens, after tokens and replace token)
         * 
         * @param list
         * @param pos
         * @return
         */
        public static int curIndentLenVT( TSourceTokenList list, int pos )
        {
                int indentLen = 0;
                for ( int i = pos; i >= 0; i-- )
                {
                        TSourceToken token = list.get( i );
                        
                        if(token.tokenstatus == ETokenStatus.tsdeleted) {
                                continue;
                        } 

                        // the after tokens in the last sourceToken should not calculated.
                        if ( i != pos && token.getTokensAfter( ).size( ) > 0 )
                        {
                                for ( int j = token.getTokensAfter( ).size( ) - 1; j >= 0; j-- )
                                {
                                        TSourceToken after = token.getTokensAfter( ).get( j );
                                        if ( after.tokentype == ETokenType.ttreturn )
                                        {
                                                return indentLen;
                                        }
                                        else if ( after.tokentype == ETokenType.ttwhitespace )
                                        {
                                                indentLen += ( after.getAstext() != null ? after.getAstext().length( )
                                                                : 0 );
                                        }
                                        else
                                        {
                                                indentLen = 0;
                                        }
                                }
                        }

                        if ( i != pos )
                        {
                                if ( token.getReplaceToken( ) != null )
                                {
                                        if ( token.getReplaceToken( ).tokentype == ETokenType.ttreturn )
                                        {
                                                return indentLen;
                                        }
                                        else if ( token.getReplaceToken( ).tokentype == ETokenType.ttwhitespace )
                                        {
                                                indentLen += ( token.getReplaceToken().getAstext() != null ? token.getReplaceToken().getAstext().length( )
                                                                : 0 );
                                        }
                                        else
                                        {
                                                indentLen = 0;
                                        }

                                }
                                else
                                {
                                        if ( token.tokentype == ETokenType.ttreturn )
                                        {
                                                return indentLen;
                                        }
                                        else if ( token.tokentype == ETokenType.ttwhitespace )
                                        {
                                                indentLen += ( token.getAstext() != null ? token.getAstext().length( )
                                                                : 0 );
                                        }
                                        else
                                        {
                                                indentLen = 0;
                                        }
                                }
                        }

                        if ( token.getTokensBefore( ).size( ) > 0 )
                        {
                                for ( int j = token.getTokensBefore( ).size( ) - 1; j >= 0; j-- )
                                {
                                        TSourceToken before = token.getTokensBefore( ).get( j );
                                        if ( before.tokentype == ETokenType.ttreturn )
                                        {
                                                return indentLen;
                                        }
                                        else if ( before.tokentype == ETokenType.ttwhitespace )
                                        {
                                                indentLen += ( before.getAstext() != null ? before.getAstext().length( )
                                                                : 0 );
                                        }
                                        else
                                        {
                                                indentLen = 0;
                                        }
                                }
                        }

                }
                return indentLen;
        }

        /**
         * calculate the current indent length VT is the abbr for "virtual token"
         * (which contains before tokens, after tokens and replace token)
         * 
         * @param token
         * @return
         */
        public static int curIndentLenVT( TSourceToken token )
        {
                return curIndentLenVT( token.container, token.posinlist );
        }

        /**
         * create the white space source token
         * 
         * @param length
         * @return
         */
        public static TSourceToken createWhitespaceSourceToken( int length )
        {
                return WhitespaceSourceTokenHelper.createWhitespaceSourceToken( length );
        }

        private static TSourceToken noFormatFlag = null;
        static
        {
                noFormatFlag = new TSourceToken( "" );
                noFormatFlag.tokentype = ETokenType.ttwhitespace;
        }

        public static TSourceToken createNoFormatFlagToken( )
        {
                return noFormatFlag;
        }

        public static TSourceToken createReturnSourceToken( )
        {
                TSourceToken t = new TSourceToken( "\n" );
                t.tokentype = ETokenType.ttreturn;
                return t;
        }

        private static final TSourceToken statementBreak = createReturnSourceToken( );

        /**
         * The one line break placed before a statement that started on the line
         * of the previous statement's terminator, so that the columns computed
         * while the statement is formatted start from that break. The empty-line
         * pass between statements removes it again and lays out the real breaks.
         */
        public static TSourceToken createStatementBreakToken( )
        {
                return statementBreak;
        }

        /**
         * combine all the white spaces into a single white space
         * 
         * @param list
         * @param startPos
         * @param endPos
         */
        public static void combineWhitespace( TSourceTokenList list, int startPos,
                        int endPos )
        {
                boolean findWhitespace = false;
                for ( int i = startPos; i < endPos; i++ )
                {
                        if ( i >= 0 && i < list.size( ) )
                        {
                                TSourceToken token = list.get( i );
                                
                                if(token.tokenstatus == ETokenStatus.tsdeleted) {
                                        continue;
                                } 
                                
                                if ( token.tokentype == ETokenType.ttwhitespace )
                                {
                                        token.setReplaceToken( SourceTokenConstant.EMPTY );
                                        findWhitespace = true;
                                }
                        }
                }
                if ( findWhitespace )
                {
                        list.get( endPos )
                                        .getTokensBefore( )
                                        .add( createWhitespaceSourceToken( 1 ) );
                }
        }

        /**
         * insert the source token before the target source token
         * 
         * @param targetToken
         * @param needAddToken
         */
        public static void addBefore( GFmtOpt opt, TSourceToken targetToken,
                        TSourceToken needAddToken )
        {
                if ( needAddToken == null )
                {
                        return;
                }

                StringBuilder buf = new StringBuilder( );
                buf.append( "AddBefore:\ntargetToken:" )
                                .append(targetToken.getAstext())
                                .append( "(pos:" )
                                .append( targetToken.posinlist )
                                .append( ")" )
                                .append( " newToken:" )
                                .append( needAddToken.getAstext().replaceAll( "\\n", "\\\\n" ) )
                                .append( "(type:" )
                                .append( needAddToken.tokentype )
                                .append( ")" );

                if ( targetToken.getTokensBefore( ).size( ) > 0 )
                {
                        buf.append( "\noldTokenBefore:" );
                        for ( int i = 0; i < targetToken.getTokensBefore( ).size( ); i++ )
                        {
                                TSourceToken token = targetToken.getTokensBefore( ).get( i );
                                
                                if(token.tokenstatus == ETokenStatus.tsdeleted) {
                                        continue;
                                } 
                                
                                buf.append( "[" )
                                                .append( token.getAstext() != null ? token.getAstext().replaceAll( "\\n",
                                                                "\\\\n" )
                                                                : "" )
                                                .append( "] " )
                                                .append( "(type:" )
                                                .append( token.tokentype )
                                                .append( ")" );
                        }
                }

                PPLogger.info( 2, buf.toString( ), null );

                if ( opt.opearateSourceToken )
                {
                        targetToken.getTokensBefore( ).add( needAddToken );
                }
        }

        public static void addAfter( GFmtOpt opt, TSourceToken targetToken,
                        TSourceToken needAddToken )
        {
                if ( needAddToken == null )
                {
                        return;
                }

                StringBuilder buf = new StringBuilder( );
                buf.append( "AddAfter:\ntargetToken:" )
                                .append(targetToken.getAstext())
                                .append( "(pos:" )
                                .append( targetToken.posinlist )
                                .append( ")" )
                                .append( " newToken:" )
                                .append( needAddToken.getAstext() != null ? needAddToken.getAstext().replaceAll( "\\n",
                                                "\\\\n" )
                                                : "" )
                                .append( "(type:" )
                                .append( needAddToken.tokentype )
                                .append( ")" );

                if ( targetToken.getTokensAfter( ).size( ) > 0 )
                {
                        buf.append( "\noldTokenAfter:" );
                        for ( int i = 0; i < targetToken.getTokensAfter( ).size( ); i++ )
                        {
                                TSourceToken token = targetToken.getTokensAfter( ).get( i );
                                
                                if(token.tokenstatus == ETokenStatus.tsdeleted) {
                                        continue;
                                } 
                                
                                buf.append( "[" )
                                                .append( token.getAstext() != null ? token.getAstext().replaceAll( "\\n",
                                                                "\\\\n" )
                                                                : "" )
                                                .append( "] " )
                                                .append( "(type:" )
                                                .append( token.tokentype )
                                                .append( ")" );
                        }
                }

                PPLogger.info( 2, buf.toString( ), null );

                if ( opt.opearateSourceToken )
                {
                        targetToken.getTokensAfter( ).add( needAddToken );
                }
        }

        /**
         * remove all source token in the before source token list VT is the abbr
         * for "virtual token" (that this method will operates before tokens, after
         * tokens and replace token)
         * 
         * @param targetToken
         */
        public static void removeAllBeforeTokenVT( GFmtOpt opt,
                        TSourceToken targetToken )
        {
                StringBuilder buf = new StringBuilder( );
                buf.append( "RemoveAllBeforeTokenVT:" );
                while ( targetToken.getTokensBefore( ).size( ) > 0 )
                {
                        TSourceToken token = targetToken.getTokensBefore( ).get( 0 );
                        
                        if(token.tokenstatus == ETokenStatus.tsdeleted) {
                                continue;
                        } 
                        
                        buf.append( "\nremoveToken:" )
                                        .append( "[" )
                                        .append( token.getAstext() != null ? token.getAstext().replaceAll( "\\n",
                                                        "\\\\n" )
                                                        : "" )
                                        .append( "] " )
                                        .append( "(type:" )
                                        .append( token.tokentype )
                                        .append( ")" );
                        if ( opt.opearateSourceToken )
                        {
                                targetToken.getTokensBefore( ).remove( 0 );
                        }
                }
                PPLogger.info( 2, buf.toString( ), null );

        }

        public static void removeThisToken( TSourceToken token )
        {
                token.setReplaceToken( SourceTokenOperator.createWhitespaceSourceToken( 1 ) );
        }
}