package org.litesoft.datt.server.boviews.podataproviders;

import java.util.*;

import org.litesoft.bo.views.communication.*;
import org.litesoft.bo.views.server.*;
import org.litesoft.core.typeutils.*;
import org.litesoft.core.util.*;
import org.litesoft.datt.client.boviews.*;
import org.litesoft.datt.client.support.*;
import org.litesoft.datt.server.*;
import org.litesoft.datt.server.boviews.*;
import org.litesoft.datt.server.pos.*;
import org.litesoft.exceptions.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.orsup.transact.*;

public class StoryViewPoServerVoDataProvider extends PoServerVoDataProvider<StoryView> implements StoryViewNames
{
    public StoryViewPoServerVoDataProvider( MetaDataStore pMetaDataStore )
    {
        super( StoryViewMetaData.getInstance(), pMetaDataStore );
    }

    @Override
    protected void LLinitialize()
    {
        super.LLinitialize();

        register( new StoryViewServerFunctionMergeStory() );
        register( new StoryViewServerFunctionFetchReprioritizeRows() );
        register( new StoryViewServerFunctionFetchInitialPrioritizeRows() );
        register( new StoryViewServerFunctionReprioritizeBetween() );
        register( new StoryViewServerFunctionReprioritizeToGroup() );
    }

    @Override
    protected WhereClause augment_getMatchingVOs( WhereClause pWhereClause )
    {
        return super.augment_getMatchingVOs( WCF.and( pWhereClause, Story.getLimitToCurrentRestrictedResource() ) ); // Add filter to where clause to only select based on RestrictedResource.
    }

    public SizedIterator<StoryView> getInitialPrioritizeVOs( Integer pMaxToReturn )
            throws PersistenceException
    {
        return getMatchingVOs( pMaxToReturn, true, WCF.isEqual( Story.CD_Priority, 0 ), new OrderBy( Story.CD_Name ) );
    }

    public SizedIterator<StoryView> getReprioritizeVOs( Integer pMaxToReturn )
            throws PersistenceException
    {
        return getMatchingVOs( pMaxToReturn, true, WCF.isNotEqual( Story.CD_Priority, 0 ), new OrderByDescending( Story.CD_Priority ) );
    }

    /**
     * Reprioritize all the pToReprioritize to the "bottom" of the pPrioritizeToGroup
     */
    public SCresult reprioritizeToGroup( PriorityGroup pPrioritizeToGroup, StoryView[] pToReprioritize )
            throws PersistenceException
    {
        try
        {
            pPrioritizeToGroup = PriorityGroup.deNull( pPrioritizeToGroup, PriorityGroup.Medium );
            UnfilteringFinder zFinder = DataStoreLocator.get().getUnfilteredFinder();
            WhereClause zWC_Bottom = pPrioritizeToGroup.isBottomInclusive() ? //
                                     WCF.isGreaterThanEqual( Story.CD_Priority, pPrioritizeToGroup.getRangeBottom() ) : //
                                     WCF.isGreaterThan( Story.CD_Priority, pPrioritizeToGroup.getRangeBottom() );
            WhereClause zWC_Top = pPrioritizeToGroup.isTopInclusive() ? //
                                  WCF.isLessThanEqual( Story.CD_Priority, pPrioritizeToGroup.getRangeTop() ) : //
                                  WCF.isLessThan( Story.CD_Priority, pPrioritizeToGroup.getRangeTop() );
            WhereClause zWhereClause = WCF.and( zWC_Bottom, zWC_Top );
            List<Story> zUpperRangeStories = zFinder.findSubset( Story.class, zWhereClause, new OrderBy( Story.CD_Priority ), 0, 1 );
            Float zUpperBound = zUpperRangeStories.isEmpty() ? pPrioritizeToGroup.getRangeTop() : zUpperRangeStories.get( 0 ).getPriority();
            return reprioritizeBetween( zFinder, new PriorityGroup.Range( pPrioritizeToGroup.getRangeBottom(), zUpperBound ), pToReprioritize );
        }
        catch ( ConcurrentModificationException e )
        {
            return staleData( e.getMessage() );
        }
    }

    /**
     * Reprioritize all the pToReprioritize between the pLowerBound & the pUpperBound.
     * If either (but not both) are null, then use the edges of the PriorityGroup indicated by the other.
     * If BOTH are null then use the bounds of PriorityGroup.Medium.
     */
    public SCresult reprioritizeBetween( StoryView pLowerBound, StoryView pUpperBound, StoryView[] pToReprioritize )
            throws PersistenceException
    {
        try
        {
            UnfilteringFinder zFinder = DataStoreLocator.get().getUnfilteredFinder();
            return reprioritizeBetween( zFinder, createRange( zFinder, pLowerBound, pUpperBound ), pToReprioritize );
        }
        catch ( ConcurrentModificationException e )
        {
            return staleData( e.getMessage() );
        }
    }

    /*
    * If either (but not both) are null, then use the edges of the PriorityGroup indicated by the other.
    * If BOTH are null then use the bounds of PriorityGroup.Medium.
     */
    private PriorityGroup.Range createRange( UnfilteringFinder zFinder, StoryView pLowerBound, StoryView pUpperBound )
    {
        switch ( DualNullCheck.of( pLowerBound, pUpperBound ) )
        {
            default:
            case BothNull:
                return PriorityGroup.Medium.getRangeAssumingExclusive();
            case Only1stNull:
                Float zUpperBound = validatePriority( zFinder, pUpperBound );
                return new PriorityGroup.Range( PriorityGroup.from( zUpperBound ).getRangeBottom(), zUpperBound );
            case Only2ndNull:
                Float zLowerBound = validatePriority( zFinder, pLowerBound );
                return new PriorityGroup.Range( zLowerBound, PriorityGroup.from( zLowerBound ).getRangeTop() );
            case NeitherNull:
                return new PriorityGroup.Range( validatePriority( zFinder, pLowerBound ), validatePriority( zFinder, pUpperBound ) );
        }
    }

    private Float validatePriority( UnfilteringFinder zFinder, StoryView pStoryView )
    {
        return validatePriority( (Story) getExistingPO( zFinder, pStoryView ), pStoryView ).getPriority();
    }

    private Story validatePriority( Story pStory, StoryView pStoryView )
    {
        if ( pStory == null )
        {
            throw new ConcurrentModificationException( "Story deleted: " + pStoryView );
        }
        if ( pStory.getIsDone() )
        {
            throw new ConcurrentModificationException( "Story 'Done': " + pStoryView );
        }
        if ( Objects.areEqual( pStory.getPriority(), pStoryView.getPriority() ) )
        {
            return pStory;
        }
        throw new ConcurrentModificationException( "Priority Changed, Story: " + pStoryView );
    }

    private SCresult staleData( String pMessage )
    {
        return VOSC.result( "Your View is Stale - Data Changed\n\n" + pMessage );
    }

    private SCresult reprioritizeBetween( UnfilteringFinder pFinder, PriorityGroup.Range pRange, StoryView[] pToReprioritize )
            throws PersistenceException
    {
        if ( Objects.isNullOrEmpty( pToReprioritize ) )
        {
            return VOSC.result( "Nothing to Reprioritize" );
        }
        Transaction zTransaction = pFinder.createUnaugmentedTransaction();
        List<Story> zStories = validate( pToReprioritize, zTransaction.findAllByKeys( Story.class, getKeysFor( pToReprioritize ) ) );
        updatePriorities( zStories, pRange.rePrioritizeBetween( extractPriorities( zStories ) ) );
        zTransaction.commit();
        return VOSC.result( "" );
    }

    private void updatePriorities( List<Story> pStories, float[] pPriorities )
    {
        for ( int i = 0; i < pStories.size(); i++ )
        {
            pStories.get( i ).setPriority( pPriorities[i] );
        }
    }

    private Float[] extractPriorities( List<Story> pStories )
    {
        Float[] zPriorities = new Float[pStories.size()];
        for ( int i = 0; i < pStories.size(); i++ )
        {
            zPriorities[i] = pStories.get( i ).getPriority();
        }
        return zPriorities;
    }

    private List<Story> validate( StoryView[] pToReprioritize, List<Story> pStories )
    {
        List<Story> zStories = new ArrayList<Story>( pToReprioritize.length );
        for ( StoryView zStoryView : pToReprioritize )
        {
            zStories.add( validatePriority( getStory( pStories, zStoryView.getID() ), zStoryView ) );
        }
        return zStories;
    }

    private Story getStory( List<Story> pStories, Long pID )
    {
        for ( Story zStory : pStories )
        {
            if ( Objects.areEqual( pID, zStory.getID() ) )
            {
                return zStory;
            }
        }
        return null;
    }

    private Collection getKeysFor( StoryView[] pToReprioritize )
    {
        List<Long> keys = new ArrayList<Long>( pToReprioritize.length );
        for ( StoryView zStoryView : pToReprioritize )
        {
            keys.add( zStoryView.getID() );
        }
        return keys;
    }

    public String mergeStory( StoryView pMergeFromStoryView, StoryView pMergeIntoStoryView )
    {
        Long zMergeIntoID = pMergeIntoStoryView.getID();
        Long zMergeFromID = pMergeFromStoryView.getID();
        if ( zMergeIntoID.equals( zMergeFromID ) )
        {
            return "Cannot merge the same Story into itself";
        }
        while ( true )
        {
            Transaction zTransaction = DataStoreLocator.get().getUnfilteredFinder().createTransaction();
            Story zMergeIntoPO = getStoryPO( zMergeIntoID, zTransaction );
            Story zMergeFromPO = getStoryPO( zMergeFromID, zTransaction );
            List<Task> zTasks = zMergeFromPO.getTasks();
            for ( Task zTask : zTasks )
            {
                zMergeIntoPO.addTasks( zTask );
            }
            zMergeIntoPO.addUpdates( new StoryUpdate( zTransaction, CurrentUserAccessor.get().getRequiredUser().freshIntoIfNotAlreadyIn( zTransaction ),
                                                      "Tasks merged from story: " + zMergeFromPO.getName() ) );

            zMergeFromPO.requestDelete();
            try
            {
                zTransaction.commit();
                return null;
            }
            catch ( ConcurrentPOModificationException e )
            {
                // Expected
            }
        }
    }

    private Story getStoryPO( Long pMergeIntoID, Transaction pTransaction )
    {
        Story zStory = (Story) findPO( pTransaction, pMergeIntoID );
        if ( zStory == null )
        {
            throw new DisplayableRuntimeException( "OneOfTheStoriesAppearsToHaveBeenDeleted" );
        }
        return zStory;
    }
}