package org.litesoft.commonfoundation.typeutils;

import sun.awt.util.*;

import java.util.*;

@SuppressWarnings("Convert2Diamond")
public class Lists
{
    public interface Provider<T>
    {
        List<T> get();
    }

    public static <T> IdentityArrayList<T> newIdentityArrayList()
    {
        return new IdentityArrayList<T>();
    }

    public static <T> ArrayList<T> newArrayList()
    {
        return new ArrayList<T>();
    }

    @SuppressWarnings("unchecked")
    public static <T> ArrayList<T> newArrayList( T... pEntries )
    {
        ArrayList<T> zList = newArrayList();
        append( zList, pEntries );
        return zList;
    }

    public static <T> ArrayList<T> newArrayList( Collection<T> pEntries )
    {
        ArrayList<T> zList = newArrayList();
        if ( pEntries != null )
        {
            zList.addAll( pEntries );
        }
        return zList;
    }

    public static <T> ArrayList<T> newArrayList( int zInitialSize )
    {
        return new ArrayList<T>( Math.max( 1, zInitialSize ) );
    }

    public static <T> List<T> newArrayList( List<T> pList1, List<T> pList2 )
    {
        ArrayList<T> zMerged = newArrayList( deNull( pList1 ) );
        zMerged.addAll( deNull( pList2 ) );
        return zMerged;
    }

    public static <T> List<T> empty()
    {
        return Collections.emptyList();
    }

    public static <T> List<T> deNull( List<T> pToCheck )
    {
        if ( pToCheck == null )
        {
            pToCheck = empty();
        }
        return pToCheck;
    }

    public static <T> List<T> deNullMutable( List<T> pToCheck )
    {
        if ( pToCheck == null )
        {
            pToCheck = newArrayList();
        }
        return pToCheck;
    }

    public static <T> List<T> deNullUnmodifiable( List<T> pToCheck )
    {
        if ( pToCheck == null )
        {
            return empty();
        }
        return Collections.unmodifiableList( pToCheck );
    }

    public static <T> List<T> deNullImmutable( List<T> pToCheck )
    {
        if ( pToCheck == null )
        {
            return empty();
        }
        return Collections.unmodifiableList( newArrayList( pToCheck ) );
    }

    public static boolean isNullOrEmpty( List<?> pToCheck )
    {
        return (pToCheck == null || pToCheck.isEmpty());
    }

    public static boolean isNotNullOrEmpty( List<?> pToCheck )
    {
        return (pToCheck != null && !pToCheck.isEmpty());
    }

    public static void assertNotNullNotEmpty( String pErrorMessage, List<?> pToAssert )
            throws IllegalArgumentException
    {
        if ( isNullOrEmpty( pToAssert ) )
        {
            Strings.errorNullOrEmpty( pErrorMessage, "Collection" );
        }
    }

    public static <T> List<T> of( T pEntry )
    {
        ArrayList<T> rv = newArrayList();
        rv.add( pEntry );
        return rv;
    }

    public static <T> List<T> from( Collection<T> pCollection )
    {
        ArrayList<T> rv = newArrayList();
        if ( pCollection != null )
        {
            rv.addAll( pCollection );
        }
        return rv;
    }

    public static <T> List<T> from( Enumeration<T> pEnumeration )
    {
        ArrayList<T> rv = newArrayList();
        while ( pEnumeration.hasMoreElements() )
        {
            rv.add( pEnumeration.nextElement() );
        }
        return rv;
    }

    public static <T> List<T> ofUnmodifiable( T pEntry )
    {
        return deNullUnmodifiable( of( pEntry ) );
    }

    public static <T> List<T> fromUnmodifiable( Collection<T> pCollection )
    {
        return deNullUnmodifiable( from( pCollection ) );
    }

    public static <T> List<T> fromUnmodifiable( Enumeration<T> pEnumeration )
    {
        return deNullUnmodifiable( from( pEnumeration ) );
    }

    @SuppressWarnings("unchecked")
    public static <T> List<T> append( List<T> pBase, T... pAdditionalEntries )
    {
        if ( pAdditionalEntries != null )
        {
            Collections.addAll( pBase, pAdditionalEntries );
        }
        return pBase;
    }

    public static <T> List<T> append( List<T> pBase, List<T> pAdditionalEntries )
    {
        pBase = deNullMutable( pBase );
        pBase.addAll( deNullMutable( pAdditionalEntries ) );
        return pBase;
    }

    public static String singleQuoteToString( List<String> pStrings )
    {
        StringBuilder sb = new StringBuilder();
        if ( pStrings != null )
        {
            char prefix = '[';
            if ( pStrings.size() == 0 )
            {
                sb.append( prefix );
            }
            else
            {
                for ( String zString : pStrings )
                {
                    sb.append( prefix );
                    sb.append( '\'' );
                    sb.append( zString );
                    sb.append( '\'' );
                    prefix = ',';
                }
            }
            sb.append( ']' );
        }
        return sb.toString();
    }
}