package org.litesoft.orsup.base;

import java.util.*;

import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.orsup.selection.*;

/**
 * This class supports sorting of Persistent Objects in memory similar to the SQL's "ORDER BY" clause.
 * <p/>
 * Since the ordering of "null" values in SQL is unspecified, it has been decided
 * for "ASCending" to place them first, and
 * for "DESCending" to place them last.
 */
public class POOrderBy
{
    public static class Result
    {
        public static final Result NULL = new Result( null );

        private final Comparator<PersistentObject<?>> mComparator;

        public Result( Comparator<PersistentObject<?>> pComparator )
        {
            mComparator = pComparator;
        }

        public Comparator<PersistentObject<?>> getComparator()
        {
            return mComparator;
        }
    }

    public static Result getComparator( MetaDataForPO pMD, OrderBy pOrderByClause )
    {
        if ( (pOrderByClause == null) )
        {
            return Result.NULL;
        }
        if ( isAcceptable( pMD, pOrderByClause ) )
        {
            return new Result( createComparator( pMD, pOrderByClause ) );
        }
        return null;
    }

    private static boolean isAcceptable( MetaDataForPO pMD, OrderBy pOrderByClause )
    {
        AttributeAccessorSCD scd =
                pMD.getAccessorSCDoptional( pOrderByClause.getColumnDefinition().getName() );
        if ( (scd != null) && scd.isPersisted() && SupplimentedSCD.Form.Local.equals( scd.getForm() ) &&
             scd.isColumnTypeComparable() )
        {
            OrderBy zSubOrderBy = pOrderByClause.getSubOrderBy();
            return (zSubOrderBy == null) || isAcceptable( pMD, zSubOrderBy );
        }
        return false;
    }

    private static MyComparator createComparator( MetaDataForPO pMD, OrderBy pOrderByClause )
    {
        if ( pOrderByClause == null )
        {
            return null;
        }
        AttributeAccessorSCD scd =
                pMD.getAccessorSCDrequired( pOrderByClause.getColumnDefinition().getName() );
        return new MyComparator( pMD.getPOregistrationName(), scd, pOrderByClause.isDescending(),
                                 createComparator( pMD, pOrderByClause.getSubOrderBy() ) );
    }

    private static class MyComparator implements Comparator<PersistentObject<?>>
    {
        private String mPORegisteredName;
        private AttributeAccessorSCD mSCD;
        private boolean mDecending;
        private MyComparator mSubComparator;

        public MyComparator( String pPORegisteredName, AttributeAccessorSCD pSCD, boolean pDecending,
                             MyComparator pSubComparator )
        {
            mPORegisteredName = pPORegisteredName;
            mSCD = pSCD;
            mDecending = pDecending;
            mSubComparator = pSubComparator;
        }

        private void chkType( PersistentObject<?> pPO )
        {
            if ( !mPORegisteredName.equals( pPO.getRegisteredName() ) )
            {
                throw new ClassCastException( "PO type: '" + pPO.getRegisteredName() + //
                                              "' != '" + mPORegisteredName + "'" );
            }
        }

        @SuppressWarnings({"unchecked"})
        private Comparable getValueOnPO( PersistentObject<?> pPO )
        {
            return (Comparable) mSCD.getValueOnPO( pPO );
        }

        public int compare( PersistentObject<?> pPO1, PersistentObject<?> pPO2 )
        {
            if ( pPO1.equals( pPO2 ) )
            {
                return 0;
            }
            chkType( pPO1 );
            chkType( pPO2 );
            return LLcompare( pPO1, pPO2 );
        }

        private int LLcompare( PersistentObject<?> pPO1, PersistentObject<?> pPO2 )
        {
            int i = CompareSupport.compare( getValueOnPO( pPO1 ), getValueOnPO( pPO2 ) );
            if ( i != 0 )
            {
                return mDecending ? -i : i;
            }
            return (mSubComparator == null) ? 0 : mSubComparator.LLcompare( pPO1, pPO2 );
        }
    }
}