package org.litesoft.GWT.client.localstorage;

import java.util.*;

import org.litesoft.core.annotations.*;
import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.core.typeutils.*;
import org.litesoft.core.util.*;

/**
 * Local Storage is a Proxy/Adapter to the underlying HTML5 LocalStorage.
 * <p/>
 * The exposed API is that of a String to String Map with three important differences:
 * <li>null keys are NOT supported</li>
 * <li>null values for values on a <code>put</code> are treated as a call to <code>remove</code></li>
 * <li>keys are trimmed of their leading and trailing whitespace and if the resulting key is empty it is treated as a null</li>
 */
public class LocalStorageImpl extends AbstractMap<String, String> implements LocalStorage
{
    private final Html5LocalStorage mHtml5LS;
    private int mVersion = 0;

    public LocalStorageImpl( Html5LocalStorage pHtml5LS )
    {
        mHtml5LS = Objects.assertNotNull( "Html5LocalStorage", pHtml5LS );
    }

    public LocalStorageImpl()
    {
        this( new Html5LocalStorageImpl() );
    }

    @Override
    public String get( @NotNull String pKey )
    {
        return innerGet( pKey );
    }

    @Override
    public String get( Object key )
    {
        return innerGet( keyToString( key ) );
    }

    @Override
    public int size()
    {
        return mHtml5LS.length();
    }

    @Override
    public void clear()
    {
        synchronized ( mHtml5LS )
        {
            if ( mHtml5LS.length() != 0 )
            {
                mHtml5LS.clear();
                mVersion++;
            }
        }
    }

    @Override
    public String put( @NotNull String pKey, @Nullable String pValue )
    {
        synchronized ( mHtml5LS )
        {
            String zPrevValue = mHtml5LS.getItem( pKey = normalize( pKey ) );
            if ( pValue == null )
            {
                mHtml5LS.removeItem( pKey );
            }
            else if ( !mHtml5LS.setItem( pKey, pValue ) )
            {
                throw new UnsupportedOperationException();
            }
            mVersion++;
            return zPrevValue;
        }
    }

    @Override
    public String remove( @NotNull Object key )
    {
        String zKey = keyToString( key );
        synchronized ( mHtml5LS )
        {
            String zPrevValue = mHtml5LS.getItem( zKey );
            if ( zPrevValue != null )
            {
                mHtml5LS.removeItem( zKey );
                mVersion++;
            }
            return zPrevValue;
        }
    }

    @Override
    public Set<Entry<String, String>> entrySet()
    {
        return new AbstractSet<Entry<String, String>>()
        {
            @Override
            public int size()
            {
                return mHtml5LS.length();
            }

            @Override
            public Iterator<Entry<String, String>> iterator()
            {
                return new AbstractReadOnlyIterator<Entry<String, String>>()
                {
                    private final int mVersion = getVersion();
                    private final int mSize = size();
                    private int mNextIndex = 0;

                    private boolean versionOK()
                    {
                        return mVersion == getVersion();
                    }

                    private boolean indexOK()
                    {
                        return mNextIndex < mSize;
                    }

                    @Override
                    public boolean hasNext()
                    {
                        synchronized ( mHtml5LS )
                        {
                            return versionOK() && indexOK();
                        }
                    }

                    @Override
                    public Entry<String, String> next()
                    {
                        synchronized ( mHtml5LS )
                        {
                            if ( !versionOK() )
                            {
                                throw new ConcurrentModificationException();
                            }
                            if ( !indexOK() )
                            {
                                throw new NoSuchElementException();
                            }
                            String zKey = mHtml5LS.key( mNextIndex++ );
                            return new OurEntry( zKey, mHtml5LS.getItem( zKey ) );
                        }
                    }
                };
            }
        };
    }

    private int getVersion()
    {
        return mVersion;
    }

    private String innerGet( String pKey )
    {
        return mHtml5LS.getItem( Strings.assertNotNullNotEmpty( "Key", pKey ) );
    }

    private String keyToString( Object pKey )
    {
        if ( (pKey == null) || (pKey instanceof String) )
        {
            return normalize( (String) pKey );
        }
        throw new IllegalArgumentException( "Key not a String, but a: " + Objects.justSimpleName( pKey ) );
    }

    private String normalize( String pKey )
    {
        return Strings.assertNotNullNotEmpty( "Key", pKey );
    }

    /**
     * Keys & Values can't be null!
     */
    private static class OurEntry implements Entry<String, String>
    {
        private final String mKey;
        private final String mValue;

        public OurEntry( String pKey, String pValue )
        {
            this.mKey = pKey;
            this.mValue = pValue;
        }

        public String getKey()
        {
            return mKey;
        }

        public String getValue()
        {
            return mValue;
        }

        public String setValue( String value )
        {
            throw new UnsupportedOperationException();
        }

        public boolean equals( Object o )
        {
            return (this == o) || ((o instanceof Map.Entry) && equals( (Map.Entry) o ));
        }

        public boolean equals( Map.Entry them )
        {
            return (this == them) || //
                   ((them != null) && //
                    mKey.equals( them.getKey() ) && //
                    mValue.equals( them.getValue() ));
        }

        public int hashCode()
        {
            return EqualSupport.hashCodeEm( mKey.hashCode(), mValue.hashCode() );
        }

        public java.lang.String toString()
        {
            return mKey + "=" + mValue;
        }
    }
}