// 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.*;

public class CodedTextManager<T extends CodedText>
{
    private CodedTextAccessor<T> mCTA;
    private List<T> mCurrent = new ArrayList<T>();

    public CodedTextManager( CodedTextAccessor<T> pCTA )
    {
        mCTA = pCTA;
    }

    @Override
    public String toString()
    {
        if ( mCurrent.isEmpty() )
        {
            return "";
        }
        StringBuilder zSB = new StringBuilder();
        for ( T zT : mCurrent )
        {
            zSB.append( zT.getText() );
        }
        return zSB.toString();
    }

    /**
     * Update the current codedText List appropriately
     *
     * @return null if more than one code changed, otherwise the 'code' of the changed entry
     *         (if the only change was the addition of a punctuation entry, then return the one just before it)
     *         (if the only change was the elimination of a punctuation entry, then return the one just before it)
     *         (if the change consisted of the elimination of a punctuation entry, and the entry just before or just after changed,
     *         then return the changed one)
     */
    public String update( String pCoded )
    {
        List<String> zCodes = CodedTextParser.parse( pCoded );
        if ( !zCodes.isEmpty() )
        {
            switch ( zCodes.size() - mCurrent.size() )
            {
                case 0:
                    return processSameLength( zCodes );
                case -1:
                    return processRemovedOne( zCodes );
                case 1:
                    return processAddedOne( zCodes );
                default:
                    break;
            }
        }
        return processRebuild( zCodes );
    }

    private static class Indexes
    {
        private int mCode, mCurrent;

        private Indexes( int pCode, int pCurrent )
        {
            mCode = pCode;
            mCurrent = pCurrent;
        }

        public int getCode()
        {
            return mCode;
        }

        public int getCurrent()
        {
            return mCurrent;
        }
    }

    private Indexes determineChanged( List<String> pCodes, int pFromCodes, int pToCodesExcluded, int pFromCurrent, int pToCurrentExcluded, int pDelta )
    {
        while ( pCodes.get( pFromCodes ).equals( mCurrent.get( pFromCurrent ).getCode() ) )
        {
            pFromCodes += pDelta;
            pFromCurrent += pDelta;
            if ( (pFromCodes == pToCodesExcluded) || pFromCurrent == pToCurrentExcluded )
            {
                break;
            }
        }
        return new Indexes( pFromCodes, pFromCurrent );
    }

    private Indexes determineChangedForward( List<String> pCodes )
    {
        return determineChanged( pCodes, 0, pCodes.size(), 0, mCurrent.size(), 1 );
    }

    private Indexes determineChangedBackward( List<String> pCodes )
    {

        return determineChanged( pCodes, pCodes.size() - 1, -1, mCurrent.size() - 1, -1, -1 );
    }

    private String processRebuild( List<String> pCodes )
    {
        mCurrent.clear();
        for ( String zCode : pCodes )
        {
            mCurrent.add( mCTA.getCodedTextFor( zCode ) );
        }
        return null;
    }

    private String processSameLength( List<String> pCodes )
    {
        List<String> zChangedCodes = new ArrayList<String>();
        for ( int i = 0; i < mCurrent.size(); i++ )
        {
            String zCurCode = mCurrent.get( i ).getCode();
            String zNewCode = pCodes.get( i );
            if ( !zCurCode.equals( zNewCode ) )
            {
                zChangedCodes.add( zNewCode );
                mCurrent.set( i, mCTA.getCodedTextFor( zNewCode ) );
            }
        }
        return (zChangedCodes.size() == 1) ? zChangedCodes.get( 0 ) : null;
    }

    /**
     * @return null if more than one code changed, otherwise:
     *         (if the only change was the addition of a punctuation entry, then return the one just before it)
     */
    private String processAddedOne( List<String> pCodes )
    {
        if ( pCodes.size() == 1 )
        {
            processRebuild( pCodes );
            return pCodes.get( 0 );
        }
        Indexes zForwardIndex = determineChangedForward( pCodes );
        Indexes zBackwardIndex = determineChangedBackward( pCodes );
        //To change body of created methods use File | Settings | File Templates.
        return null;
    }

    /**
     * @return null if more than one code changed, otherwise:
     *         (if the only change was the elimination of a punctuation entry, then return the one just before it)
     *         (if the change consisted of the elimination of a punctuation entry, and the entry just before or just after changed,
     *         then return the changed one)
     */
    private String processRemovedOne( List<String> pCodes )
    {
        Indexes zForwardIndex = determineChangedForward( pCodes );
        Indexes zBackwardIndex = determineChangedBackward( pCodes );
        //To change body of created methods use File | Settings | File Templates.
        return null;
    }
}