package org.litesoft.boviews.podataproviders.support;

import org.litesoft.bo.*;
import org.litesoft.bo.views.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.exceptions.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.otherattributeaccessors.*;
import org.litesoft.orsup.selection.*;

public class WhereClauseSupport {
    private static final WhereClauseFactory FACTORY = WhereClauseFactory.INSTANCE;

    private Finder mFinder;
    private MetaDataForPO mPoMetaData;
    private DerivedFromAttributeSource mDerivedFromAttributeSource;

    public WhereClauseSupport( Finder pFinder, MetaDataForPO pPoMetaData, DerivedFromAttributeSource pDerivedFromAttributeSource ) {
        mFinder = pFinder == null ? DataStoreLocator.get().getUnfilteredFinder() : pFinder;
        mPoMetaData = pPoMetaData;
        mDerivedFromAttributeSource = pDerivedFromAttributeSource;
    }

    public WhereClause createWhereClause( SSMap... pORed_ANDFiltersNotNullNotEmpty ) {
        if ( pORed_ANDFiltersNotNullNotEmpty.length == 0 ) {
            return FACTORY.alwaysTrue();
        }
        WhereClause zWhereClause = FACTORY.alwaysFalse();
        for ( SSMap zMap : pORed_ANDFiltersNotNullNotEmpty ) {
            WhereClause zMapWhereClause = createWhereClause( zMap );
            if ( FACTORY.alwaysTrue() == zMapWhereClause ) {
                return zMapWhereClause;
            }
            zWhereClause = FACTORY.or( zWhereClause, zMapWhereClause );
        }
        return zWhereClause;
    }

    protected WhereClause createWhereClause( SSMap pFilters ) {
        if ( pFilters instanceof NoRowsMatchingFilterMap ) {
            return FACTORY.alwaysFalse();
        }
        WhereClause zWhereClause = FACTORY.alwaysTrue();
        if ( (pFilters != null) && !pFilters.isEmpty() ) {
            boolean zEquals = (pFilters instanceof EqualsMatchingFilterMap);
            for ( String zAttributeName : pFilters.keySet() ) {
                WhereClause zWhereClauseForAttribute = createWhereClause( zEquals, zAttributeName, pFilters.get( zAttributeName ).trim() );
                if ( zWhereClauseForAttribute == FACTORY.alwaysFalse() ) {
                    return FACTORY.alwaysFalse();
                }
                zWhereClause = FACTORY.and( zWhereClause, zWhereClauseForAttribute );
            }
        }
        return zWhereClause;
    }

    protected WhereClause createWhereClause( boolean pEquals, String pAttributeName, String pAttributeValue ) {
        if ( pAttributeValue.length() == 0 ) {
            return FACTORY.alwaysFalse();
        }
        String zAttributePath = mDerivedFromAttributeSource.getDerivedFromAttributePath( pAttributeName );
        if ( zAttributePath == null ) {
            return createWhereClauseForNonDerivedAttribute( pEquals, pAttributeName, pAttributeValue );
        }

        AttributeAccessorSCDpath.Node[] zPathNodes = new AttributeAccessorSCDpath( mFinder, mPoMetaData ) {
            @Override
            protected boolean isAcceptableLeaf( AttributeAccessorSCD pSCD ) {
                return (pSCD instanceof AttributeAccessorSCDsimplePersistedRegular) || (null != getAcceptableRelationship( pSCD ));
            }
        }.createPath( zAttributePath );
        if ( Currently.isNullOrEmpty( zPathNodes ) ) {
            return createWhereClauseForUnacceptableAttributePath( pEquals, pAttributeName, pAttributeValue, zAttributePath );
        }
        AttributeAccessorSCD zLastAA = zPathNodes[zPathNodes.length - 1].getAttributeAccessor();
        boolean zIsString = BoAttribute.AttributeType.String.equals( zLastAA.getAMD().getType().getBoAttributeType() );
        if ( zPathNodes.length > 1 ) {
            throw new NotImplementedYetException( "relationships: " + zAttributePath );
        }

        AttributeAccessorSCD zSCD = zPathNodes[0].getAttributeAccessor();
        if ( !zIsString ) {
            return createWhereClauseForAttributeTypeNotString( pEquals, pAttributeName, pAttributeValue, zSCD );
        }
        if ( pEquals ) {
            return FACTORY.isEqual( zSCD, pAttributeValue );
        }
        String[] zParts = Strings.parseChar( pAttributeValue, '*' );
        if ( zParts.length == 1 ) {
            zParts = Strings.appendString( zParts, "" );
        }
        return FACTORY.like( zSCD, zParts );
    }

    @SuppressWarnings({"UnusedParameters"})
    protected WhereClause createWhereClauseForNonDerivedAttribute( boolean pEquals, String pAttributeName, String pAttributeValue ) {
        return FACTORY.alwaysFalse();  // todo: Decide what to do about non-dervived attributes
    }

    @SuppressWarnings({"UnusedParameters"})
    protected WhereClause createWhereClauseForUnacceptableAttributePath( boolean pEquals, String pAttributeName, String pAttributeValue, String pAttributePath ) {
        return FACTORY.alwaysFalse();  // todo: Decide to fix AttributeAccessorSCDpathNode to throw exception or DO NOTHING
    }

    @SuppressWarnings({"UnusedParameters"})
    protected WhereClause createWhereClauseForAttributeTypeNotString( boolean pEquals, String pAttributeName, String pAttributeValue,
                                                                      AttributeAccessorSCD pSCD ) {
        return FACTORY.isEqual( pSCD, pAttributeValue ); // todo: Form not String?
    }
}