// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.sql;

import org.litesoft.db.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.nonpublic.*;
import org.litesoft.orsup.selection.*;

public class SQLORPersistenceHelper extends SQLPersistenceHelper implements ORPersistenceHelper
{
    public SQLORPersistenceHelper( SQLDBconnectionProvider pSQLDBconnectionProvider )
    {
        super( pSQLDBconnectionProvider );
    }

    // ORPersistenceHelper vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

    @Override
    public long count( boolean pIncludingImmortalInactives, //
                       MetaDataForPO pMetaDataForPO, //
                       WhereClause pSelectionWhereClause )
            throws DBException
    {
        String whereClause = SQL_OR_Helper.toSQL( pIncludingImmortalInactives, pMetaDataForPO, pSelectionWhereClause );
        return rawCount( pMetaDataForPO.getTableName(), whereClause );
    }

    /**
     * @param pFinder               - either a NonTransactionalFinder or a Transaction
     * @param pMetaDataForPO        - Persisted Object MetaData
     * @param pSelectionWhereClause - null means all
     * @param pOrderBy              - null means order immaterial
     * @param pOffset               - Rows to Skip (>= 0 verified)
     * @param pLimit                - Max Rows to return (>= 1 verified)
     *
     * @return !Null
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @Override
    public POQueryIterator findSubset( Finder pFinder, //
                                       boolean pIncludingImmortalInactives, //
                                       MetaDataForPOinternalExtension pMetaDataForPO, //
                                       WhereClause pSelectionWhereClause, OrderBy pOrderBy, //
                                       long pOffset, int pLimit )
            throws DBException
    {
        DBconnection zDBconnection = createConnection();
        try
        {
            String selectColumns = SQL_OR_Helper.buildAllSelectColumns( pMetaDataForPO );
            String tableName = pMetaDataForPO.getTableName();
            String wc = SQL_OR_Helper.toSQL( pIncludingImmortalInactives, pMetaDataForPO, pSelectionWhereClause );
            String orderBy = SQL_OR_Helper.toSQL( pMetaDataForPO, pOrderBy );
            String zCmd = getHelper().buildQuery( zDBconnection.getDBinfo().getProductVersion(), //
                                                  tableName, selectColumns, wc, orderBy, pOffset, pLimit );

            return new SQLORPersistenceHelper.MyPOQueryIterator( pMetaDataForPO, pFinder, this, zCmd, zDBconnection );
        }
        catch ( DBException e )
        {
            zDBconnection.dispose();
            throw e;
        }
    }

    @Override
    public POQueryIterator findAllCursored( Finder pFinder, POQueryFilter pPOQueryFilter, //
                                            boolean pIncludingImmortalInactives, //
                                            MetaDataForPOinternalExtension pMetaDataForPO, //
                                            WhereClause pSelectionWhereClause, OrderBy pOrderBy )
            throws DBException
    {
        return new SQLORPersistenceHelper.MyPOQueryIterator( pMetaDataForPO, pFinder, pPOQueryFilter, this, SQL_OR_Helper.buildQuery( pIncludingImmortalInactives, //
                                                                                                                                      pMetaDataForPO, //
                                                                                                                                      pSelectionWhereClause, pOrderBy ) );
    }

    @Override
    public POKeyIterator findAllKeysCursored( POKeyQueryFilter pPOKeyQueryFilter, //
                                              boolean pIncludingImmortalInactives, //
                                              MetaDataForPOinternalExtension pMetaDataForPO, //
                                              SimpleColumnDefinition pKeyColumn, WhereClause pSelectionWhereClause, OrderBy pOrderBy )
            throws DBException
    {
        return new SQLORPersistenceHelper.MyPOKeyIterator( pPOKeyQueryFilter, this, //
                                                           SQL_OR_Helper.buildQuery( pIncludingImmortalInactives, //
                                                                                     pMetaDataForPO, pKeyColumn.getColumnName(),
                                                                                     //
                                                                                     pSelectionWhereClause, pOrderBy ) );
    }

    @Override
    public void createTables( TableManager pTableManager, MetaDataForPO pMetaDataForPO )
            throws DBException
    {
        createTable( pMetaDataForPO );
        for ( MetaDataForPO.Index index : pMetaDataForPO.getIndexes() )
        {
            createIndex( pMetaDataForPO, index );
        }
        pTableManager.addTable( pMetaDataForPO.getTableName() );
    }

    @Override
    public void reCreateIndices( MetaDataForPO pMetaDataForPO )
            throws DBException
    {
        for ( MetaDataForPO.Index index : pMetaDataForPO.getIndexes() )
        {
            dropIndex( index );
            createIndex( pMetaDataForPO, index );
        }
    }

    @Override
    public void createIndex( MetaDataForPO pMetaDataForPO, MetaDataForPO.Index index )
    {
        StringBuilder cmd = new StringBuilder( "CREATE" );
        if ( index.isUnique() )
        {
            cmd.append( " UNIQUE" );
        }
        cmd.append( " INDEX " );
        cmd.append( index.getIndexName() );
        cmd.append( " ON " );
        cmd.append( pMetaDataForPO.getTableName() );
        cmd.append( " (" );
        String[] columns = index.getColumns();
        cmd.append( columns[0] );
        for ( int i = 1; i < columns.length; ++i )
        {
            cmd.append( ", " ).append( columns[i] );
        }
        cmd.append( ")" );
        executeNoResultsNoCommitSQL( cmd.toString() );
    }

    // ORPersistenceHelper ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    @SuppressWarnings({"unchecked"})
    protected WhereClause createVersionAwareWhereClause( MetaDataForPO pMetaDataForPO, PersistentObjectImpl pPersistentObject )
    {
        WhereClause wc = pPersistentObject.getPersistentObjectUniqueKey().convertToWC();
        if ( pMetaDataForPO.isRecordVersionable() )
        {
            String rvName = pMetaDataForPO.getRecordVersionAttributeName();
            AttributeAccessorSCD rvAASCD = pMetaDataForPO.getAccessorSCDrequired( rvName );
            WhereClauseFactory f = WhereClauseFactory.INSTANCE;
            wc = f.and( wc, f.isEqual( rvAASCD, rvAASCD.getValueOnPO( pPersistentObject ) ) );
        }
        return wc;
    }

    private void createTable( MetaDataForPO pMetaDataForPO )
            throws DBException
    {
        StringBuilder cmd = new StringBuilder();
        cmd.append( "CREATE TABLE " );
        cmd.append( pMetaDataForPO.getTableName() );
        cmd.append( " ( " );

        SQL_OR_Helper.processPersistingAccessorSCDs( cmd, "", pMetaDataForPO, new SQL_OR_Helper.PersistingAccessorSCDprocessor()
        {
            @Override
            public boolean process( StringBuilder pSB, String pPrefix, AttributeAccessorSCD pSCD )
            {
                pSB.append( pPrefix );
                createTableColumn( pSB, pSCD );
                return true;
            }
        } );

        AttributeAccessorKeySet keySet = pMetaDataForPO.getKeySet();
        if ( keySet != null )
        {
            cmd.append( ", CONSTRAINT " ).append( pMetaDataForPO.getTableName() ).append( "_PK PRIMARY KEY (" ).append( keySet.getColumns() ).append( ")" );
        }
        cmd.append( " )" );

        executeNoResultsNoCommitSQL( cmd.toString() );
    }

    private void dropIndex( MetaDataForPO.Index index )
    {
        String cmd = "DROP INDEX " + index.getIndexName();
        try
        {
            executeNoResultsNoCommitSQL( cmd );
        }
        catch ( DBException e )
        {
            // Whatever...
        }
    }

    private static class MyPOQueryIterator extends AbstractRowSourcePOQueryIterator<PersistentObject>
    {
        public MyPOQueryIterator( MetaDataForPOinternalExtension pMetaDataForPO, Finder pFinder, POQueryFilter pPOQueryFilter, SQLPersistenceHelper pPersistenceHelper, String pCmd )
        {
            this( pMetaDataForPO, pFinder, pPOQueryFilter, pPersistenceHelper, pCmd, null );
        }

        public MyPOQueryIterator( MetaDataForPOinternalExtension pMetaDataForPO, Finder pFinder, //
                                  SQLPersistenceHelper pPersistenceHelper, String pCmd, DBconnection pDBconnection )
        {
            this( pMetaDataForPO, pFinder, null, pPersistenceHelper, pCmd, pDBconnection );
        }

        private MyPOQueryIterator( MetaDataForPOinternalExtension pMetaDataForPO, Finder pFinder, POQueryFilter pPOQueryFilter, SQLPersistenceHelper pPersistenceHelper, String pCmd, DBconnection pDBconnection )
        {
            super( pMetaDataForPO, pFinder, pPOQueryFilter, new MyRowSource( pPersistenceHelper, pCmd, pDBconnection ) );
        }
    }

    private static class MyPOKeyIterator extends AbstractPOKeyIterator
    {
        public MyPOKeyIterator( POKeyQueryFilter pPOKeyQueryFilter, SQLPersistenceHelper pPersistenceHelper, String pCmd )
        {
            super( pPOKeyQueryFilter, new MyRowSource( pPersistenceHelper, pCmd, null ) );
        }
    }

    //private boolean indexDefinitionIsUpToDate( MetaDataForPO pMetaDataForPO, MetaDataForPO.Index pIndex )
    //        throws ORMapperException
    //{
    //    List<String> metadataColumns = Arrays.asList( pIndex.getColumns() );
    //    Collections.sort( metadataColumns );
    //    List<String> existingColumns = getIndexColumns( pMetaDataForPO.getTableName(), pIndex.getIndexName() );
    //    Collections.sort( existingColumns );
    //    return existingColumns.equals( metadataColumns );
    //}
}