package org.robsite.extension.rss.model;
   
   import java.beans.XMLDecoder;
   import java.beans.XMLEncoder;
   
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.OutputStream;
   
  import java.net.MalformedURLException;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.swing.AbstractListModel;
  
  import javax.xml.parsers.ParserConfigurationException;
  
  import oracle.ide.util.CollectionListener;
  import oracle.ide.util.Copyable;
  import oracle.ide.util.Pair;
  import oracle.ide.util.TransientMarker;
  import oracle.ide.xml.SAXParserDoneException;
  
  import org.robsite.extension.rss.util.ListEvent;
  import org.robsite.extension.rss.util.ListListener;
  
  import org.xml.sax.SAXException;
  
  public class Channels implements Copyable
  {
    private Pair _channels = new Pair();
    private List _collectionListeners = null;
    
    public Channels()
    {
      _channels.setFirst( new ArrayList() );
      _channels.setSecond( new ArrayList() );
    }
    
    public void addListListener( ListListener cl )
    {
      if ( _collectionListeners == null )
      {
        _collectionListeners = new ArrayList();
      }
      _collectionListeners.add( cl );
    }
    
    public void removeListListener( ListListener cl )
    {
      if ( _collectionListeners == null )
      {
        throw new IllegalStateException( "No listeners" ) ;
      }
      _collectionListeners.remove( cl );
    }
    
    private void fireIntervalAdded( int start, int end )
    {
      if ( _collectionListeners == null || _collectionListeners.isEmpty() )
      {
        return;
      }
      // Must always copy listener lists.
      ListListener[] listeners = (ListListener[]) _collectionListeners.toArray( 
        new ListListener[ _collectionListeners.size() ]);
      ListEvent le = new ListEvent( getSubscribedChannels(), start, end );
      
      for ( int i=0; i < listeners.length; i++ )
      {
        listeners[ i ].itemsAdded( le );
      }
    }
    
    private void fireIntervalRemoved( int start, int end )
    {
      if ( _collectionListeners == null || _collectionListeners.isEmpty() )
      {
        return;
      }
      // Must always copy listener lists.
      ListListener[] listeners = (ListListener[]) _collectionListeners.toArray( 
        new ListListener[ _collectionListeners.size() ]);
      ListEvent le = new ListEvent( getSubscribedChannels(), start, end );
      
      for ( int i=0; i < listeners.length; i++ )
      {
        listeners[ i ].itemsRemoved( le );
      }
    }  
    
    private void fireIntervalChanged( int start, int end )
    {
      if ( _collectionListeners == null || _collectionListeners.isEmpty() )
     {
       return;
     }
     // Must always copy listener lists.
     ListListener[] listeners = (ListListener[]) _collectionListeners.toArray( 
       new ListListener[ _collectionListeners.size() ]);
     ListEvent le = new ListEvent( getSubscribedChannels(), start, end );
     
     for ( int i=0; i < listeners.length; i++ )
     {
       listeners[ i ].itemsChanged( le );
     }
   }    
   
   public Pair getChannelInfo()
   {
     return _channels;
   }
   
   public void setChannelInfo( Pair pair )
   {
     _channels = pair;
   }
   
   public List getSubscribedChannels()
   {
     if ( _channels != null )
     {
       return (List) _channels.getFirst();
     }
     
     return Collections.EMPTY_LIST;
   }
   
   public List getUnsubscribedChannels()
   {
     if ( _channels != null )
     {
       return (List) _channels.getSecond();
     }
     
     return Collections.EMPTY_LIST;
   }
   
   public void setSubscribedChannels( List subscribed ) 
     throws TransientMarker
   {
     int oldSize = getSubscribedChannels().size();
     _channels.setFirst( subscribed );
     fireIntervalRemoved(  0, oldSize -1 );
     fireIntervalAdded(  0, getSubscribedChannels().size() -1 );
   }
   
   public void setUnsubscribedChannels( List unsubscribed )
     throws TransientMarker  
   {
     _channels.setSecond( unsubscribed );   
   }
 
   
   public List getAllChannels()
   {
     ArrayList list = new ArrayList();
     list.addAll( getSubscribedChannels() );
     list.addAll( getUnsubscribedChannels() );
     
     return Collections.unmodifiableList( list );
   }
 
   public void save( OutputStream os )
   {
     XMLEncoder encoder = new XMLEncoder( os );
     encoder.writeObject( _channels );
     encoder.close();
   }
 
   
   public void load( InputStream is )
   {
     XMLDecoder decoder = new XMLDecoder( is );
     Object o = decoder.readObject();
     
     if ( o instanceof Pair )
     {
       _channels = (Pair) o;
     }
     
     decoder.close();
   }
   
   public int checkChannel( int channelIndex )
     throws MalformedURLException, SAXException, IOException, ParserConfigurationException
   {
     Channel channel = (Channel) getSubscribedChannels().get( channelIndex );
   
     int itemCount = channel.getItems() == null ? 0 : channel.getItems().size();
     SimpleRSSParser.parse( channel );
     int newItems = channel.getItems().size() - itemCount;
     
     fireChannelUpdated( channelIndex );
     
     return newItems;
   }
 
   public void fireChannelUpdated( Channel channel )
   {
     int index = getSubscribedChannels().indexOf( channel );
     if ( index >= 0 )
     {
       fireChannelUpdated( index );
     }
   }
 
   private void fireChannelUpdated( int channelIndex )
   {
     fireIntervalChanged( channelIndex, channelIndex );
   }
 
   /***
    * Add a channel. All channels start off subscribed.
    * 
    * @param c
    */
   public void addChannel( Channel c )
   {
     // Only allow a channel to be added if it's not already subscribed or 
     // unsubscribed.
     if ( ! getSubscribedChannels().contains( c ) && 
          ! getUnsubscribedChannels().contains( c ) )
     {
       List subscribedChannels = getSubscribedChannels();
       subscribedChannels.add( c );
       fireIntervalAdded(  subscribedChannels.size() - 1, subscribedChannels.size() - 1 );
     }
   }
   
   public void removeChannel( Channel c )
   {
     int pos = getSubscribedChannels().indexOf( c );
     if ( pos >= 0 )
     {
       getSubscribedChannels().remove( pos );
       fireIntervalRemoved( pos, pos );
     }
     else
     {
       // See if it's an unsubscribed one.
       pos = getUnsubscribedChannels().indexOf( c );
       if ( pos >= 0 )
       {
         getUnsubscribedChannels().remove( pos );
       }
     }
   }
   
   public void setChannelSubscribed( Channel channel, boolean isSubscribed )
   {
     List sourceList = isSubscribed ? getUnsubscribedChannels() : 
       getSubscribedChannels();
     
     int sourceIndex = sourceList.indexOf( channel );
     if ( sourceIndex >= 0 )
     {
       List destList = isSubscribed ? getSubscribedChannels() : 
         getUnsubscribedChannels();
       destList.add( sourceList.get( sourceIndex ) );
       sourceList.remove( sourceIndex );
       
       // We need to fire an event to indicate what happened to the subscribed
       // list only.
       if ( isSubscribed )
       {
         // If isSubscribed, a channel was added to the subscribed list
         fireIntervalAdded(  
           destList.size() - 1, destList.size() -1 );
       }
       else
       {
         // Else, a channel was removed.
         fireIntervalRemoved( 
           sourceIndex, sourceIndex );
       }
     }
   }
   
   public boolean isChannelSubscribed( Channel channel )
   {
     return getSubscribedChannels().contains( channel );
   }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Copyable interface
 ///////////////////////////////////////////////////////////////////////////////
 
   public Object copyTo(Object target)
   {
     final Channels copy = 
       target != null ? (Channels) target : new Channels();
     
     copy._channels = new Pair();
     copy._channels.first = new ArrayList( (Collection)_channels.first );
     copy._channels.second = new ArrayList( (Collection)_channels.second );
     
     
     return copy;
   }
   
 }