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

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

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

public abstract class AbstractPersistenceHelper implements PersistenceHelper
{
    /**
     * @return Converted pIdentifier based on the "Caseing" of this DB.
     */
    @Override
    public final String normalizeIdentifier( String pIdentifier )
    {
        if ( pIdentifier != null )
        {
            if ( (pIdentifier = pIdentifier.trim()).length() != 0 )
            {
                return LLnormalizeIdentifierNotNullOrEmpty( pIdentifier );
            }
        }
        return pIdentifier;
    }

    /**
     * @return Converted pIdentifier based on the "Caseing" of this DB.
     */
    abstract protected String LLnormalizeIdentifierNotNullOrEmpty( String pIdentifier );

    /**
     * Determine all the tables that are made up of the 'pTableNameParts' where if only 1, then must be equal,
     * otherwise the found table names will: "start with" the first element of the pTableNameParts array &&
     * "end with" the last element of the pTableNameParts array && contain (in order with no overlap) all the
     * the middle elements of the pTableNameParts.
     *
     * @param pTableNameParts Non-null & not-empty list of strings that make up a pattern to match table names
     *
     * @return Non-null list of the matching table names - which may be empty.
     *
     * @throws DBException - Exception regarding the DB
     */
    @Override
    public final String[] getTables( String... pTableNameParts )
            throws DBException
    {
        pTableNameParts = Strings.deNull( pTableNameParts );
        String[] zParts = new String[pTableNameParts.length];
        int zPartsLength = 0;
        for ( int i = 0; i < pTableNameParts.length; i++ )
        {
            zPartsLength += (zParts[i] = Strings.deNull( pTableNameParts[i] )).length();
        }
        if ( zPartsLength == 0 )
        {
            return Strings.EMPTY_ARRAY;
        }
        for ( int i = zParts.length - 2; i > 0; i-- )
        {
            if ( zParts[i].length() == 0 )
            {
                String[] newParts = new String[zParts.length - 1];
                int zTo = 0;
                for ( int zFrom = 0; zFrom < zParts.length; zFrom++ )
                {
                    if ( zFrom != i )
                    {
                        newParts[zTo++] = zParts[zFrom];
                    }
                }
                zParts = newParts;
            }
        }
        switch ( zParts.length )
        {
            case 1:
                return LLgetTablesEquals( zParts[0] );
            case 2:
                if ( zParts[1].length() == 0 )
                {
                    return LLgetTablesStartsWith( zParts[0] );
                }
                if ( zParts[0].length() == 0 )
                {
                    return LLgetTablesEndsWith( zParts[1] );
                }
                return LLgetTablesStartsAndEndsWith( zParts[0], zParts[1] );
            default:
                return LLgetTablesForParts( zParts );
        }
    }

    /**
     * Determine all the columns for a table.
     *
     * @param pTableName Non-null & not-empty table name.
     *
     * @return Non-null list of the table's columns - which may be empty.
     *
     * @throws NoTableException        - No Table was found for the given pTableName
     * @throws MultipleTablesException - Multiple Tables were found for the given pTableName
     * @throws DBException             - Some other Exception regarding the DB
     */
    @Override
    public final DBtableColumn[] getColumns( String pTableName )
            throws NoTableException, MultipleTablesException, DBException
    {
        Map<String, DBtableColumn[]> zMap = LLgetColumns( pTableName = Strings.assertNotNullNotEmpty( "TableName", pTableName ) );
        return checkMap( pTableName, zMap );
    }

    /**
     * Determine all the indexes for a table.
     *
     * @param pTableName Non-null & not-empty table name.
     *
     * @return Non-null list of the table's indexes - which may be empty.
     *
     * @throws NoTableException        - No Table was found for the given pTableName
     * @throws MultipleTablesException - Multiple Tables were found for the given pTableName
     * @throws DBException             - Some other Exception regarding the DB
     */
    @Override
    public final DBtableIndex[] getIndexes( String pTableName )
            throws NoTableException, MultipleTablesException, DBException
    {
        Map<String, DBtableIndex[]> zMap = LLgetIndexes( pTableName = Strings.assertNotNullNotEmpty( "TableName", pTableName ) );
        return checkMap( pTableName, zMap );
    }

    /**
     * Determine all the columns for a table.
     *
     * @param pSimpleFromIdentifier Non-null
     *
     * @return Non-null list of the table's columns - which may be empty.
     *
     * @throws NoTableException        - No Table was found for the given pTableName
     * @throws MultipleTablesException - Multiple Tables were found for the given pTableName
     * @throws DBException             - Some other Exception regarding the DB
     */
    @Override
    public final DBtableColumn[] getColumns( SimpleFromIdentifier pSimpleFromIdentifier )
            throws NoTableException, MultipleTablesException, DBException
    {
        return getColumns( normalizeIdentifier( pSimpleFromIdentifier.getTableName() ) );
    }

    /**
     * Determine all the indexes for a table.
     *
     * @param pSimpleFromIdentifier Non-null
     *
     * @return Non-null list of the table's indexes - which may be empty.
     *
     * @throws NoTableException        - No Table was found for the given pTableName
     * @throws MultipleTablesException - Multiple Tables were found for the given pTableName
     * @throws DBException             - Some other Exception regarding the DB
     */
    @Override
    public final DBtableIndex[] getIndexes( SimpleFromIdentifier pSimpleFromIdentifier )
            throws NoTableException, MultipleTablesException, DBException
    {
        return getIndexes( normalizeIdentifier( pSimpleFromIdentifier.getTableName() ) );
    }

    /**
     * @return TRUE if index exists,
     *         FALSE if index appears to not exist
     */
    @Override
    public final boolean indexExists( SimpleFromIdentifier pSimpleFromIdentifier, String pIndexName )
            throws DBException
    {
        DBtableIndex[] zIndexes = getIndexes( pSimpleFromIdentifier );
        for ( DBtableIndex zIndex : zIndexes )
        {
            if ( zIndex.getIndexName().equalsIgnoreCase( pIndexName ) )
            {
                return true;
            }
        }
        return false;
    }

    abstract protected String[] LLgetTablesEquals( String pName );

    abstract protected String[] LLgetTablesStartsWith( String pStart );

    abstract protected String[] LLgetTablesEndsWith( String pEnd );

    abstract protected String[] LLgetTablesStartsAndEndsWith( String pStart, String pEnd );

    abstract protected String[] LLgetTablesForParts( String[] pParts );

    abstract protected Map<String, DBtableColumn[]> LLgetColumns( String pTableName )
            throws DBException;

    abstract protected Map<String, DBtableIndex[]> LLgetIndexes( String pTableName )
            throws DBException;

    private <T> T checkMap( String pTableName, Map<String, T> pMap )
    {
        if ( pMap.isEmpty() )
        {
            throw new NoTableException( "No Table found with Name: '" + pTableName + "'" );
        }
        if ( pMap.size() == 1 )
        {
            return pMap.values().iterator().next();
        }
        throw MultipleTablesException.createFrom( pTableName, pMap.keySet() );
    }
}