// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.core.util;

import java.util.*;

import org.litesoft.charstreams.*;
import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.core.simpletypes.temporal.nonpublic.*;
import org.litesoft.core.typeutils.*;

public class UtilsCommon extends EqualSupport
{
    protected UtilsCommon()
    {
    }

    public static String cvtTextForDisplay( String pText )
    {
        if ( pText == null )
        {
            return "[null]";
        }
        int length = pText.length();
        StringBuilder sb = new StringBuilder( length );
        for ( int i = 0; i < length; i++ )
        {
            char c = pText.charAt( i );
            switch ( c )
            {
                case '[':
                case ']':
                case '\\':
                case '"':
                    sb.append( '\\' );
                    sb.append( c );
                    break;
                case '\n':
                    sb.append( "\\n" );
                    break;
                case '\r':
                    sb.append( "\\r" );
                    break;
                case '\t':
                    sb.append( "\\t" );
                    break;
                case '\f':
                    sb.append( "\\f" );
                    break;
                default:
                    if ( (' ' <= c) && (c < 127) )
                    {
                        sb.append( c );
                        break;
                    }
                    sb.append( '[' );
                    sb.append( Characters.cvtCharForDisplay( c ) );
                    sb.append( ']' );
                    break;
            }
        }
        return sb.toString();
    }

    public static Object[] convert( int pEntries, Enumeration<Object> pEnumeration )
    {
        Object[] them = new Object[pEntries];
        for ( int i = 0; (i < pEntries) && pEnumeration.hasMoreElements(); i++ )
        {
            them[i] = pEnumeration.nextElement();
        }
        return them;
    }

    // Groups

    // Object Group:

    @SuppressWarnings({"unchecked", "ManualArrayToCollectionCopy", "MismatchedQueryAndUpdateOfCollection"})
    public static <T> Collection<T> convert( Collection<T> pCollectionToFill, Object[] pObjects )
    {
        Collection<Object> toFill = (Collection<Object>) pCollectionToFill;
        for ( Object object : pObjects )
        {
            toFill.add( object );
        }
        return pCollectionToFill;
    }

    public static void appendClassName( StringBuilder pBuffer, int pTabLevel, String pLabel, Object pValue )
    {
        append( pBuffer, pTabLevel, pLabel, (pValue == null) ? null : pValue.getClass().getName() );
    }

    public static void append( StringBuilder pBuffer, int pTabLevel, String pLabel, Object pValue )
    {
        append( pBuffer, pTabLevel, pLabel );
        pBuffer.append( ':' );
        pBuffer.append( (pValue == null) ? "null" : pValue.toString() );
    }

    public static void append( StringBuilder pBuffer, int pTabLevel, String pValue )
    {
        pBuffer.append( '\n' );
        while ( pTabLevel-- >= 1 )
        {
            pBuffer.append( '\t' );
        }
        pBuffer.append( (pValue == null) ? "null" : pValue );
    }

    public static String normalizeCtrlChars( String pText )
    {
        if ( pText != null )
        {
            for ( int i = pText.length(); i-- > 0; )
            {
                if ( pText.charAt( i ) < ' ' )
                {
                    StringBuilder sb = new StringBuilder( pText );
                    for (; i >= 0; i-- )
                    {
                        char c = sb.charAt( i );
                        if ( c < ' ' )
                        {
                            switch ( c )
                            {
                                case '\n':
                                case '\r':
                                case '\f':
                                    break;
                                case '\t':
                                    sb.setCharAt( i, ' ' );
                                    break;
                                default:
                                    sb.setCharAt( i, '.' );
                                    break;
                            }
                        }
                        pText = sb.toString();
                    }
                    break;
                }
            }
        }
        return pText;
    }

    /**
     * Given path(s) that may be system dependent, create a path
     * that is converted to a system independent form (forward Slashes).
     * Note: Ignore null entries (null, or all nulls returns null).
     */
    public static String forwardSlashPath( String... pPaths )
    {
        StringBuilder sb = null;
        if ( pPaths != null )
        {
            for ( String path : pPaths )
            {
                if ( path != null )
                {
                    if ( sb == null )
                    {
                        sb = new StringBuilder();
                    }
                    if ( path.length() != 0 )
                    {
                        String fsp = Paths.forwardSlash( path );
                        if ( sb.length() == 0 )
                        {
                            sb.append( fsp );
                        }
                        else
                        {
                            boolean pStartsWithSlash = (fsp.charAt( 0 ) == '/');
                            if ( sb.charAt( sb.length() - 1 ) == '/' )
                            {
                                sb.append( pStartsWithSlash ? fsp.substring( 1 ) : fsp );
                            }
                            else
                            {
                                if ( !pStartsWithSlash )
                                {
                                    sb.append( '/' );
                                }
                                sb.append( fsp );
                            }
                        }
                    }
                }
            }
        }
        return (sb == null) ? null : sb.toString();
    }

    /**
     * @param pText !null
     */
    public static void formatToJavaSourceString( StringBuilder pSB, String pText )
    {
        LowLevelEncode( pSB, new CharSourceFromSequence( pText ), true );
    }

    public static String encodeToConstrainedASCII( String pText )
    {
        if ( Strings.isNullOrEmpty( pText ) )
        {
            return pText;
        }
        return LowLevelEncode( new StringBuilder(), new CharSourceFromSequence( pText, 0 ), true ).toString();
    }

    public static String decodeFromConstrainedASCII( String pText )
    {
        if ( Strings.isNullOrEmpty( pText ) )
        {
            return pText;
        }
        return LowLevelDecode( new StringBuilder(), new CharSourceFromSequence( pText, 0 ), false ).toString();
    }

    private static StringBuilder LowLevelEncode( StringBuilder pSB, CharSource pSource, boolean pDoubleQuoteSpecial )
    {
        for ( int c; -1 != (c = pSource.get()); )
        {
            if ( pDoubleQuoteSpecial && (c == '"') )
            {
                pSB.append( '\\' );
                pSB.append( (char) c );
            }
            else
            {
                switch ( c )
                {
                    case '\\':
                        pSB.append( '\\' );
                        pSB.append( '\\' );
                        break;
                    case '\n':
                        pSB.append( '\\' );
                        pSB.append( 'n' );
                        break;
                    case '\r':
                        pSB.append( '\\' );
                        pSB.append( 'r' );
                        break;
                    case '\t':
                        pSB.append( '\\' );
                        pSB.append( 't' );
                        break;
                    default:
                        if ( (' ' <= c) && (c < 127) )
                        {
                            pSB.append( (char) c );
                            break;
                        }
                        pSB.append( '\\' );
                        pSB.append( 'x' );
                        pSB.append( Hex.toChar( c >> 24 ) );
                        pSB.append( Hex.toChar( c >> 16 ) );
                        pSB.append( Hex.toChar( c >> 8 ) );
                        pSB.append( Hex.toChar( c ) );
                        break;
                }
            }
        }
        return pSB;
    }

    private static StringBuilder LowLevelDecode( StringBuilder pSB, CharSource pSource, boolean pDoubleQuoteSpecial )
    {
        for ( int c; -1 != (c = pSource.get()); )
        {
            if ( (c < ' ') || (127 <= c) )
            {
                throw new IllegalArgumentException( "Decoding Error: Char[" + pSource.getLastOffset() + "] Not between ' ' & Ascii 126 (inclusive)" );
            }
            if ( c != '\\' )
            {
                pSB.append( (char) c );
                continue;
            }
            if ( -1 == (c = pSource.get()) )
            {
                throw new IllegalArgumentException( "Decoding Error: No Char after escape \\" );
            }
            if ( pDoubleQuoteSpecial && (c == '"') )
            {
                pSB.append( (char) c );
            }
            else
            {
                switch ( c )
                {
                    case '\\':
                        pSB.append( (char) c );
                        break;
                    case 'n':
                        pSB.append( '\n' );
                        break;
                    case 'r':
                        pSB.append( '\r' );
                        break;
                    case 't':
                        pSB.append( '\t' );
                        break;
                    case 'x':
                        int c1 = pSource.get();
                        int c2 = pSource.get();
                        int c3 = pSource.get();
                        int c4 = pSource.get();
                        if ( c4 == -1 )
                        {
                            throw new IllegalArgumentException( "Decoding Error: Not enough Chars after \\x" );
                        }
                        try
                        {
                            int zChar = (Hex.fromCharChecked( (char) c1 ) << 24) + //
                                        (Hex.fromCharChecked( (char) c2 ) << 16) + //
                                        (Hex.fromCharChecked( (char) c3 ) << 8) + //
                                        Hex.fromCharChecked( (char) c4 );
                            pSB.append( (char) zChar );
                        }
                        catch ( IllegalArgumentException e )
                        {
                            throw new IllegalArgumentException( "Decoding Error: After \\x expected 4 hex digits: " + e.getMessage() );
                        }
                        break;
                    default:
                        throw new IllegalArgumentException( "Decoding Error: Invalid Char '" + c + "' after escape \\" );
                }
            }
        }
        return pSB;
    }

    // Array / varArgs

    // Objects:

    // Object Group:

    public static SimpleDate forceEndOfMonth( SimpleDate pSimpleDate )
    {
        if ( pSimpleDate != null )
        {
            int zDaysInMonth = CalendarSupport.daysInMonth( pSimpleDate.getYear(), pSimpleDate.getMonth() );
            if ( pSimpleDate.getDay() != zDaysInMonth )
            {
                pSimpleDate.setDay( zDaysInMonth );
            }
        }
        return pSimpleDate;
    }
}