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

import java.util.*;

import org.litesoft.core.simpletypes.*;
import org.litesoft.core.util.*;

public class CodedTextAccessor<T extends CodedText>
{
    private Map<Character, List<T>> mCodedTextsByCodeFirstChar = new HashMap<Character, List<T>>();

    public CodedTextAccessor( List<T> pCodedTexts )
    {
        if ( (pCodedTexts != null) && !pCodedTexts.isEmpty() )
        {
            List<T> zAll = new ArrayList<T>( pCodedTexts ); // copy to injsure that we can sort it
            Collections.sort( zAll );

            Helper zHelper = new Helper();
            for ( T zCodedText : zAll )
            {
                zHelper.process( zCodedText );
            }
            zHelper.fini();
        }
    }

    public CodedTextAccessor( T... pCodedTexts )
    {
        if ( (pCodedTexts != null) && (pCodedTexts.length != 0) )
        {
            Arrays.sort( pCodedTexts );

            Helper zHelper = new Helper();
            for ( T zCodedText : pCodedTexts )
            {
                zHelper.process( zCodedText );
            }
            zHelper.fini();
        }
    }

    public CodedTextAccessor( String... pCodes )
    {
        if ( (pCodes != null) && (pCodes.length != 0) )
        {
            Arrays.sort( pCodes );

            Helper zHelper = new Helper();
            for ( String zCode : pCodes )
            {
                zHelper.process( createSame( zCode ) );
            }
            zHelper.fini();
        }
    }

    public List<T> getListFor( String pCodeStartsWith )
    {
        if ( (pCodeStartsWith != null) && (pCodeStartsWith.length() != 0) )
        {
            pCodeStartsWith = pCodeStartsWith.toUpperCase();
            List<T> zList = mCodedTextsByCodeFirstChar.get( pCodeStartsWith.charAt( 0 ) );
            if ( zList != null )
            {
                return (pCodeStartsWith.length() == 1) ? zList : createFilteredList( zList, pCodeStartsWith );
            }
        }
        return ImmutableArrayList.emptyList();
    }

    private List<T> createFilteredList( List<T> pList, String pCodeStartsWith )
    {
        ArrayList<T> zList = new ArrayList<T>();
        for ( T zView : pList )
        {
            if ( zView.getCode().startsWith( pCodeStartsWith ) )
            {
                zList.add( zView );
            }
        }
        return zList;
    }

    public T getCodedTextFor( String pCode )
    {
        if ( (pCode == null) || (pCode.length() == 0) )
        {
            return null;
        }
        String zCode = pCode.toUpperCase();
        List<T> zList = mCodedTextsByCodeFirstChar.get( zCode.charAt( 0 ) );
        if ( zList != null )
        {
            for ( T zView : zList )
            {
                if ( zView.getCode().equals( zCode ) )
                {
                    return zView;
                }
            }
        }
        return createSame( pCode );
    }

    @SuppressWarnings({"unchecked"})
    private T createSame( String pCode )
    {
        return (T) createRawSame( pCode );
    }

    private static CodedText createRawSame( String pCode )
    {
        if ( pCode.length() == 1 )
        {
            switch ( pCode.charAt( 0 ) )
            {
                case ' ':
                    return CodedText.SPACE;
                case ',':
                    return CodedText.SPACE;
                case '.':
                    return CodedText.PERIOD;
                default:
                    break;
            }
        }
        return new CodedText.Same( pCode );
    }

    private class Helper
    {
        private char mCurChar = ' ';
        private List<T> mCurList = new ArrayList<T>();

        public void process( T pCodedText )
        {
            String zCode = pCodedText.getCode();
            if ( (zCode != null) && (zCode.length() > 0) )
            {
                char zChar = zCode.charAt( 0 );
                if ( zChar != mCurChar )
                {
                    if ( !mCurList.isEmpty() )
                    {
                        mCodedTextsByCodeFirstChar.put( mCurChar, mCurList );
                        mCurList = new ArrayList<T>();
                    }
                    mCurChar = zChar;
                }
                mCurList.add( pCodedText );
            }
        }

        public void fini()
        {
            if ( !mCurList.isEmpty() )
            {
                mCodedTextsByCodeFirstChar.put( mCurChar, mCurList );
            }
        }
    }
}