package org.litesoft.GWT.client.widgets.datatables;

import java.util.*;

import org.litesoft.GWT.client.event.*;
import org.litesoft.core.util.*;

import com.google.gwt.event.shared.*;
import com.google.gwt.gen2.table.client.*;
import com.google.gwt.gen2.table.client.TableModelHelper.*;

/**
 * A {@link TableModel} which persists its data and implements the {@link List}
 * interface.
 */
public class ListTableModel<RowType> extends TableModel<RowType> implements List<RowType>,
                                                                            HasUpdateHandlers
{
    private final HandlerManager mHandlers = new HandlerManager( this );
    protected List<RowType> mList = new ArrayList<RowType>();

    public ListTableModel()
    {
        this( Collections.<RowType>emptyList() );
    }

    public ListTableModel( List<RowType> pList )
    {
        mList.addAll( pList );
        updateRowCount();
    }

    public HandlerRegistration addUpdateHandler( UpdateHandler pHandler )
    {
        return mHandlers.addHandler( UpdateEvent.getType(), pHandler );
    }

    protected void updateRowCount()
    {
        setRowCount( mList.size() );
    }

    public void fireEvent( GwtEvent<?> pEvent )
    {
        mHandlers.fireEvent( pEvent );
    }

    @Override
    public void requestRows( Request pRequest, Callback<RowType> pCallback )
    {
        pCallback.onRowsReady( pRequest, new TableModelHelper.Response<RowType>()
        {
            @Override
            public Iterator<RowType> getRowValues()
            {
                return iterator();
            }
        } );
        UpdateEvent.fire( this );
    }

    public boolean contains( Object pO )
    {
        return mList.contains( pO );
    }

    public boolean containsAll( Collection<?> pC )
    {
        return mList.containsAll( pC );
    }

    public RowType get( int pIndex )
    {
        return mList.get( pIndex );
    }

    public int indexOf( Object pO )
    {
        return mList.indexOf( pO );
    }

    public boolean isEmpty()
    {
        return mList.isEmpty();
    }

    public Iterator<RowType> iterator()
    {
        return mList.iterator();
    }

    public int lastIndexOf( Object pO )
    {
        return mList.lastIndexOf( pO );
    }

    public List<RowType> subList( int pFromIndex, int pToIndex )
    {
        List<RowType> zList = mList;
        ArrayList<RowType> result = new ArrayList<RowType>();
        for ( int i = pFromIndex; i < pToIndex; i++ )
        {
            result.add( zList.get( i ) );
        }
        return new ImmutableArrayList<RowType>( result );
    }

    public ListIterator<RowType> listIterator()
    {
        return mList.listIterator();
    }

    public ListIterator<RowType> listIterator( int pIndex )
    {
        return mList.listIterator( pIndex );
    }

    public void add( int pIndex, RowType pElement )
    {
        mList.add( pIndex, pElement );
        updateRowCount();
    }

    public boolean add( RowType pO )
    {
        boolean result = mList.add( pO );
        updateRowCount();
        return result;
    }

    public boolean addAll( Collection<? extends RowType> pC )
    {
        boolean result = mList.addAll( pC );
        updateRowCount();
        return result;
    }

    public boolean addAll( int pIndex, Collection<? extends RowType> pC )
    {
        boolean result = mList.addAll( pIndex, pC );
        updateRowCount();
        return result;
    }

    public void clear()
    {
        mList.clear();
        updateRowCount();
    }

    public RowType remove( int pIndex )
    {
        RowType result = mList.remove( pIndex );
        updateRowCount();
        return result;
    }

    public boolean remove( Object pO )
    {
        boolean result = mList.remove( pO );
        updateRowCount();
        return result;
    }

    public boolean removeAll( Collection<?> pC )
    {
        boolean result = mList.removeAll( pC );
        updateRowCount();
        return result;
    }

    public boolean retainAll( Collection<?> pC )
    {
        boolean result = mList.retainAll( pC );
        updateRowCount();
        return result;
    }

    public RowType set( int pIndex, RowType pElement )
    {
        return mList.set( pIndex, pElement );
    }

    public void setAll( Iterator<RowType> pIterator )
    {
        mList.clear();
        while ( pIterator.hasNext() )
        {
            mList.add( pIterator.next() );
        }
        updateRowCount();
    }

    public void setAll( Collection<? extends RowType> pC )
    {
        mList.clear();
        addAll( pC );
    }

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

    public Object[] toArray()
    {
        return mList.toArray();
    }

    @SuppressWarnings({"SuspiciousToArrayCall"})
    public <T> T[] toArray( T[] pA )
    {
        return mList.toArray( pA );
    }

    @SuppressWarnings({"EqualsWhichDoesntCheckParameterClass"}) @Override
    public boolean equals( Object pO )
    {
        return mList.equals( pO );
    }

    @Override
    public int hashCode()
    {
        return mList.hashCode();
    }

    @Override
    public String toString()
    {
        return mList.toString();
    }
}