package org.litesoft.core.typeutils;

import org.litesoft.core.util.*;

public class Objects
{
    public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];

    public static void assertNull( String pObjectName, Object pToBeAssert )
            throws IllegalArgumentException
    {
        if ( pToBeAssert != null )
        {
            throw new IllegalArgumentException( pObjectName + ": Expected null, but was'" + pToBeAssert + "'" );
        }
    }

    public static <T> T assertNotNull( String pObjectName, T pToBeAssert )
            throws IllegalArgumentException
    {
        if ( pToBeAssert == null )
        {
            throw new IllegalArgumentException( pObjectName + UtilsCommon.NOT_ALLOWED_TO_BE_NULL );
        }
        return pToBeAssert;
    }

    public static void assertEqual( String pObjectName, Object pExpected, Object pActual )
            throws IllegalArgumentException
    {
        if ( null == pExpected && null == pActual )
        {
            return;
        }
        if ( null != pExpected && !pExpected.equals( pActual ) )
        {
            throw new IllegalArgumentException( pObjectName + ": Expected '" + pExpected + "', but was '" + pActual + "'" );
        }
    }

    public static boolean areNonArraysEqual( Object pThis, Object pThat )
    {
        if ( pThis == pThat ) // Same or both null
        {
            return true;
        }
        // Both CAN'T be null
        return (pThis != null) ? pThis.equals( pThat ) : pThat.equals( pThis );
    }

    public static <T> T deNull( T pToCheck, T pDefault )
    {
        return (pToCheck != null) ? pToCheck : pDefault;
    }

    public static Object[] appendObjectArrays( Object[] pArray1, Object[] pArray2 )
    {
        if ( isNullOrEmpty( pArray2 ) )
        {
            return pArray1;
        }
        if ( isNullOrEmpty( pArray1 ) )
        {
            return pArray2;
        }
        Object[] joined = new Object[pArray1.length + pArray2.length];
        System.arraycopy( pArray1, 0, joined, 0, pArray1.length );
        System.arraycopy( pArray2, 0, joined, pArray1.length, pArray2.length );
        return joined;
    }

    public static Object[] prependObject( Object pNewFirst, Object[] pTheRest )
    {
        return appendObjectArrays( new Object[]{pNewFirst}, pTheRest );
    }

    public static Object[] appendObject( Object[] pCurArray, Object pNewLast )
    {
        return appendObjectArrays( pCurArray, new Object[]{pNewLast} );
    }

    public static boolean isNotNullOrEmpty( Object[] pArrayToCheck )
    {
        return ((pArrayToCheck != null) && (pArrayToCheck.length != 0));
    }

    public static boolean isNullOrEmpty( Object[] pArrayToCheck )
    {
        return ((pArrayToCheck == null) || (pArrayToCheck.length == 0));
    }

    public static boolean areArraysEqual( Object[] pThis, Object[] pThat )
    {
        if ( pThis == pThat ) // handles if both are null
        {
            return true;
        }
        if ( (pThis != null) && (pThat != null) && (pThis.length == pThat.length) )
        {
            for ( int i = pThis.length; --i >= 0; )
            {
                if ( !UtilsCommon.areEqual( pThis[i], pThat[i] ) )
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    private static void assertElementsNotNull( String pErrorMessage, Object[] pArrayToAssert )
            throws IllegalArgumentException
    {
        for ( int i = pArrayToAssert.length; --i >= 0; )
        {
            if ( pArrayToAssert[i] == null )
            {
                Strings.errorNullOrEmpty( pErrorMessage, "Object[" + i + "]" );
            }
        }
    }

    public static void assertNotNullAndElementsNotNull( String pErrorMessage, Object[] pArrayToAssert )
            throws IllegalArgumentException
    {
        if ( pArrayToAssert == null )
        {
            Strings.errorNullOrEmpty( pErrorMessage, "Object[]" );
        }
        assertElementsNotNull( pErrorMessage, pArrayToAssert );
    }

    public static void assertNotNullNotEmptyAndElementsNotNull( String pErrorMessage, Object[] pArrayToAssert )
            throws IllegalArgumentException
    {
        assertNotNullNotEmpty( pErrorMessage, pArrayToAssert );
        assertElementsNotNull( pErrorMessage, pArrayToAssert );
    }

    public static void assertNotNullNotEmpty( String pErrorMessage, Object[] pArrayToAssert )
            throws IllegalArgumentException
    {
        if ( isNullOrEmpty( pArrayToAssert ) )
        {
            Strings.errorNullOrEmpty( pErrorMessage, "Object[]" );
        }
    }

    public static boolean isNotNull( Object pToCheck )
    {
        return (pToCheck != null);
    }

    public static int getNonNullEntryCount( Object[] pArrayToCheck )
    {
        int rv = 0;
        if ( pArrayToCheck != null )
        {
            for ( int i = pArrayToCheck.length; --i >= 0; )
            {
                if ( pArrayToCheck[i] != null )
                {
                    rv++;
                }
            }
        }
        return rv;
    }

    public static boolean hasEntries( Object[] pArrayToCheck )
    {
        if ( pArrayToCheck != null )
        {
            for ( int i = pArrayToCheck.length; --i >= 0; )
            {
                if ( pArrayToCheck[i] != null )
                {
                    return true;
                }
            }
        }
        return false;
    }
}