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

import java.io.*;
import java.util.*;

import org.litesoft.core.typeutils.*;
import org.litesoft.core.typeutils.Objects;

/**
 * A List 'like' class that is type safe for <String>, <HDSList>, & <HDSMap>.
 * <p/>
 * It does NOT quite really implement the List interface because proper Concurrent Modification is not recognized.
 * For this reason, it is NOT coded to be Thread Safe!
 * <p/>
 * Note: AFAIK, Generics do not support multiple different types.
 */
public class HDSList extends AbstractList<Object> implements Serializable
{
    private static final long serialVersionUID = 1L;

    public static final String TYPE = "HDSList";

    private ArrayList<Entry> mEntries = new ArrayList<Entry>();

    public HDSList()
    {
    }

    public int size()
    {
        return mEntries.size();
    }

    public Object get( int index )
    {
        return unwrapType( mEntries.get( index ) );
    }

    @Override
    public Object set( int index, Object element )
    {
        return unParent( unwrapType( mEntries.set( index, new Entry( this, element ) ) ) );
    }

    @Override
    public void add( int index, Object element )
    {
        mEntries.add( index, new Entry( this, element ) );
    }

    @Override
    public Object remove( int index )
    {
        return unParent( unwrapType( mEntries.remove( index ) ) );
    }

    @Override
    public void clear()
    {
        if ( !mEntries.isEmpty() )
        {
            super.clear();
        }
    }

    private Object unParent( Object pObject )
    {
        if ( pObject != null )
        {
            if ( pObject instanceof HDSMap )
            {
                ((HDSMap) pObject).setHDSParent( null );
            }
            else if ( pObject instanceof HDSList )
            {
                ((HDSList) pObject).setHDSParent( null );
            }
        }
        return pObject;
    }

    private Object unwrapType( Entry pElement )
    {
        return (pElement != null) ? pElement.getValue() : null;
    }

    public void desiccate( HierarchicalDataSink pSink )
    {
        populate( pSink.createRootNode( TYPE ) );
    }

    public void desiccate( HierarchicalDataSink.Node pParentNode )
    {
        populate( pParentNode.createChildNode( TYPE ) );
    }

    private void populate( HierarchicalDataSink.Node pNode )
    {
        pNode.setAttribute( "size", "" + mEntries.size() );
        for ( Entry zEntry : mEntries )
        {
            zEntry.desiccate( pNode );
        }
        pNode.done();
    }

    public HDSList( HierarchicalDataSource.Node pNode )
    {
        String zStrSize = Strings.assertNotNullNotEmpty( TYPE + " 'size' attribute", pNode.getAttributeValue( "size" ) );
        int zExpectedSize;
        try
        {
            zExpectedSize = Integer.parseInt( zStrSize );
        }
        catch ( NumberFormatException e )
        {
            throw new IllegalArgumentException( TYPE + " 'size' attribute Not Numeric", e );
        }
        int zActualSize = 0;
        for ( HierarchicalDataSource.Node zNode; null != (zNode = pNode.getNextChild()); )
        {
            zActualSize++;
            mEntries.add( new Entry( zNode ) );
        }
        if ( zActualSize != zExpectedSize )
        {
            throw new IllegalArgumentException( TYPE + " rehydrate, expected '" + zExpectedSize + "' members, but got: " + zActualSize );
        }
    }

    static class Entry implements Serializable
    {
        // Use multiple variables as there is no "reasonable" (for Serializing) common parent
        protected String mValueAsLocalString;
        protected HDSMap mValueAsChildMap;
        protected HDSList mValueAsChildList;

        Entry()
        {
        }

        Entry( Object pOwner, Object pValue )
        {
            if ( pValue instanceof String )
            {
                mValueAsLocalString = pValue.toString();
            }
            else if ( pValue instanceof HDSMap )
            {
                (mValueAsChildMap = (HDSMap) pValue).setHDSParent( pOwner );
            }
            else if ( pValue instanceof HDSList )
            {
                (mValueAsChildList = (HDSList) pValue).setHDSParent( pOwner );
            }
            else if ( pValue == null )
            {
                throw new NullPointerException( "Value" );
            }
            else
            {
                throw new IllegalArgumentException( "Unsupported Type: " + pValue );
            }
        }

        public Object getValue()
        {
            return (mValueAsLocalString != null) ? mValueAsLocalString : (mValueAsChildMap != null) ? mValueAsChildMap : mValueAsChildList;
        }

        public String getValueAsLocalString()
        {
            return mValueAsLocalString;
        }

        public HDSMap getValueAsChildMap()
        {
            return mValueAsChildMap;
        }

        public HDSList getValueAsChildList()
        {
            return mValueAsChildList;
        }

        public void desiccate( HierarchicalDataSink.Node pParentNode )
        {
            if ( getValueAsLocalString() != null )
            {
                HierarchicalDataSink.Node zNode = pParentNode.createChildNode( "String" );
                zNode.setAttribute( "of", getValueAsLocalString() );
                zNode.done();
            }
            else if ( getValueAsChildMap() != null )
            {
                getValueAsChildMap().desiccate( pParentNode );
            }
            else
            {
                getValueAsChildList().desiccate( pParentNode );
            }
        }

        Entry( HierarchicalDataSource.Node pNode )
        {
            String zName = pNode.getName();
            if ( "String".equals( zName ) )
            {
                Objects.assertNotNull( "String Value", mValueAsLocalString = pNode.getAttributeValue( "of" ) );
            }
            else if ( HDSMap.TYPE.equals( zName ) )
            {
                mValueAsChildMap = new HDSMap( pNode );
            }
            else if ( HDSList.TYPE.equals( zName ) )
            {
                mValueAsChildList = new HDSList( pNode );
            }
            else
            {
                throw new IllegalArgumentException( "Unrecognized " + TYPE + " Member Node of: " + zName );
            }
            pNode.assertNoMoreChildren();
        }
    }

    private transient Object mHDSParent = null;

    void setHDSParent( Object pHDSParent )
    {
        if ( (pHDSParent != null) && (mHDSParent != null) )
        {
            throw new IllegalStateException( "An " + TYPE + " may only be 'held' by ONE other HDS 'type' (" + HDSMap.TYPE + " or " + TYPE + ")" );
        }
        mHDSParent = pHDSParent;
    }
}