// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.core;

import org.litesoft.commonfoundation.typeutils.Objects;

import java.util.*;

public class ClassToInstanceMapperImpl implements ClassToInstanceMapper
{
    public ClassToInstanceMapperImpl()
    {
    }

    private Map<Class<?>, NoInstanceFactory<?>> mFactoriesByClass = new HashMap<Class<?>, NoInstanceFactory<?>>();
    private Map<Class<?>, Object> mInstanceByClass = new HashMap<Class<?>, Object>();

    /**
     * Get a List (!null) of all the currently "set" Factories
     */
    public synchronized List<NoInstanceFactory<?>> getNoInstanceFactories()
    {
        return new ArrayList<NoInstanceFactory<?>>( mFactoriesByClass.values() );
    }

    /**
     * Set a Factory into this Mapper.  This Factory is used to create an Instance (and register it) when "get" is called and no Instance is currently registered.
     *
     * @param pFactory !null
     *
     * @throws IllegalArgumentException if pFactory is null
     * @throws IllegalStateException    if this is a duplicate Factory
     */
    public void setNoInstanceFactory( NoInstanceFactory<?> pFactory )
    {
        Objects.assertNotNull( "NoInstanceFactory", pFactory );
        Class<?> zClass = pFactory.getFor();
        assertClass( zClass );
        synchronized ( this )
        {
            NoInstanceFactory<?> zFactory = mFactoriesByClass.get( zClass );
            if ( zFactory == null )
            {
                mFactoriesByClass.put( zClass, pFactory );
                return;
            }
        }
        throw new IllegalStateException( "Duplicate Factory for: " + zClass );
    }

    /**
     * @param pClass !null
     *
     * @return null if not found or current instance set / replaced
     *
     * @throws IllegalArgumentException if pClass is null
     */
    public <T> T checkGet( Class<T> pClass )
            throws IllegalArgumentException
    {
        assertClass( pClass );
        synchronized ( this )
        {
            //noinspection unchecked
            return (T) mInstanceByClass.get( pClass );
        }
    }

    /**
     * Get the previously 'registered' (set &/ replaced) instance of pClass.
     * NOTE: if there is no instance currently registered, then one is attempted to be added using a previously registered NoInstanceFactory.
     *
     * @param pClass !null
     *
     * @return instance of pClass
     *
     * @throws IllegalArgumentException if pClass is null
     * @throws IllegalStateException    if no instance previously 'registered' for pClass
     */
    public <T> T get( Class<T> pClass )
            throws IllegalArgumentException, IllegalStateException
    {
        assertClass( pClass );
        Object zInstance;
        synchronized ( this )
        {
            if ( null == (zInstance = mInstanceByClass.get( pClass )) )
            {
                NoInstanceFactory<?> zFactory = mFactoriesByClass.get( pClass );
                if ( zFactory != null )
                {
                    if ( null != (zInstance = zFactory.createInstance()) )
                    {
                        mInstanceByClass.put( pClass, zInstance );
                    }
                }
            }
        }
        if ( zInstance == null )
        {
            throw new IllegalStateException( "No instance found for: " + pClass );
        }
        //noinspection unchecked
        return (T) zInstance;
    }

    /**
     * Set or register an instance (pInstance) of pClass, that is NOT currently 'registered' (previously set &/ replaced, but not subsequently removed)
     *
     * @param pClass    !null
     * @param pInstance !null
     *
     * @throws IllegalArgumentException if either pClass or pInstance is null
     * @throws IllegalStateException    if an instance for pClass IS currently 'registered'
     */
    public <T, V extends T> void set( Class<T> pClass, V pInstance )
            throws IllegalArgumentException, IllegalStateException
    {
        assertClassAndInstance( pClass, pInstance );
        synchronized ( this )
        {
            Object zInstance = mInstanceByClass.get( pClass );
            if ( zInstance == null )
            {
                mInstanceByClass.put( pClass, pInstance );
                return;
            }
        }
        throw new IllegalStateException( "Already an instance for: " + pClass );
    }

    /**
     * Replace or re-register an instance (pInstance) of pClass, that IS currently 'registered' (previously set &/ replaced, but not subsequently removed)
     *
     * @param pClass    !null
     * @param pInstance !null
     *
     * @throws IllegalArgumentException if either pClass or pInstance is null
     * @throws IllegalStateException    if an instance for pClass is NOT currently 'registered'
     */
    public <T, V extends T> void replace( Class<T> pClass, V pInstance )
            throws IllegalArgumentException, IllegalStateException
    {
        assertClassAndInstance( pClass, pInstance );
        synchronized ( this )
        {
            Object zInstance = mInstanceByClass.get( pClass );
            if ( zInstance != null )
            {
                mInstanceByClass.put( pClass, pInstance );
                return;
            }
        }
        throw new IllegalStateException( "No instance to replace for: " + pClass );
    }

    /**
     * Remove the instance (pInstance) of pClass, that IS currently 'registered' (previously set &/ replaced, but not subsequently removed)
     *
     * @param pClass    !null
     * @param pInstance !null
     *
     * @throws IllegalArgumentException if either pClass or pInstance is null
     * @throws IllegalStateException    if pInstance of pClass is NOT currently 'registered' for pClass
     */
    public <T, V extends T> void remove( Class<T> pClass, V pInstance )
            throws IllegalArgumentException, IllegalStateException
    {
        assertClassAndInstance( pClass, pInstance );
        Object zInstance;
        synchronized ( this )
        {
            zInstance = mInstanceByClass.get( pClass );
            if ( pInstance == zInstance )
            {
                mInstanceByClass.remove( pClass );
                return;
            }
        }
        if ( zInstance == null )
        {
            throw new IllegalStateException( "No instance currently exists for: " + pClass );
        }
        throw new IllegalStateException( "Instance to remove '" + pInstance + "' mismatchs found '" + zInstance + "' for: " + pClass );
    }

    public synchronized void clearAllInstances()
    {
        mInstanceByClass.clear();
    }

    private void assertClass( Class<?> pClass )
    {
        Objects.assertNotNull( "Class (key)", pClass );
    }

    private void assertClassAndInstance( Class<?> pClass, Object pInstance )
    {
        assertClass( pClass );
        Objects.assertNotNull( "pInstance (value)", pInstance );
    }
}