/*
     Copyright 2004-2005 robsite.org
         
      Licensed under the Apache License, Version 2.0 (the "License"); 
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
         
          http://www.apache.org/licenses/LICENSE-2.0
         
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
   */
   
  package org.robsite.extension.rss;
  
  import java.io.InputStream;
  import java.util.ArrayList;
  
  import java.util.Map;
  import javax.swing.Timer;
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  import oracle.ide.Ide;
  import oracle.ide.IdeAction;
  import oracle.ide.IdeEvent;
  import oracle.ide.IdeListener;
  import oracle.ide.MenuConstants;
  import oracle.ide.addin.Addin;
  import oracle.ide.addin.Controller;
  import oracle.ide.docking.DockStation;
  import oracle.ide.panels.Navigable;
  
  import oracle.javatools.Environment;
  
  import org.robsite.extension.rss.model.Channels;
  
  /***
   * The RSS News Reader extension.
   * 
   * @author brian_duff@sourceforge.net
   * @version $Revision: 1.1.1.1 $
   */
  public class NewsFeedExtension implements Addin 
  {
    public static final String VIEW_ID = "RSSNewsWindow";
    static final String PREFS_KEY = "newsFeedPrefs";
  
    private ArrayList _changeListeners = new ArrayList();
    private static NewsFeedExtension s_instance;
    private NewsDockableWindow _dockableWindow;
    
    private ResHelper _res = new ResHelper( "Extension" );
    
    /***
     * The runnable that actually checks news.
     */
    private NewsCheckRunnable _checkRunnable;
    
    /***
     * The timer that notifies the news check runnable to wake up and check
     * news periodically.
     */
    private Timer _timer;
    
    
  
    /***
     * Get the singleton news feed extension. 
     * 
     * @return get the only instance of this extension class. May return null
     *    if the extension has not been initialized.
     */
    public static NewsFeedExtension get()
    {
      return s_instance;
    }
    
    /***
     * Get the news dockable window.
     * 
     * @return the news dockable window. This may be null if the window has
     *    never been shown or is currently not visible.
     */
    public synchronized NewsDockableWindow getNewsDockable()
    {
      return _dockableWindow;
    }
    
    /***
     * Set the news dockable window. This is used only by the news dockable
     * window itself to notify the extension when the window is visible.
     * 
     * @param newsDockable the news dockable.
     */
    synchronized void setNewsDockable( NewsDockableWindow newsDockable )
    {
     _dockableWindow = newsDockable;
     // Always force an update of news when the dockable is shown.
     if ( newsDockable != null && _checkRunnable != null )
     {
       _checkRunnable.forceUpdate();
     }
   }
   
   /***
    * Get the preferences object.
    * 
    * @return preferences.
    */
   public NewsFeedPreferences getPreferences()
   {
     NewsFeedPreferences prefs = (NewsFeedPreferences) 
       Ide.getSettings().getData( PREFS_KEY );  
       
     if ( prefs == null )
     {
       prefs = new NewsFeedPreferences();
       prefs.setCheckDelaySeconds( 600 ); // Ten minutes.
       prefs.setHTTPTimeout( 3000 );
       prefs.setCheckAutomatically( true );
       prefs.setSyncChannels( true );
       prefs.setCheckOnStartup( true );
       prefs.setDirectoryURL( "http://otn.oracle.com/products/jdev/htdocs/partners/addins/exchange/rss/newsdirectory.xml" );
       
       Ide.getSettings().putData( PREFS_KEY, prefs );
     }
     
     return prefs;
   }
   
   public Channels getChannels()
   {
     return getPreferences().getChannels();
   }
   
   /***
    * Start (or restart) the timer which periodically updates.
    */
   private void restartTimer()
   {
     if ( _timer != null )
     {
       _timer.stop();
       _timer = null;
     }
     
     if ( getPreferences().isCheckAutomatically() )
     {
       _timer = new Timer(  
         getPreferences().getCheckDelaySeconds() * 1000,
         _checkRunnable
       );
       _timer.setRepeats( true );
       _timer.start();
     }
   }
   
 ///////////////////////////////////////////////////////////////////////////////
 // Addin implementation
 ///////////////////////////////////////////////////////////////////////////////
 
   public void initialize()
   {
     s_instance = this;
     
     // Install version number into Help->About
     Ide.getVersionInfo().addComponent(
       NewsFeedExtension.class.getPackage().getSpecificationTitle(),
       NewsFeedExtension.class.getPackage().getImplementationVersion()
     );    
     
     // Register the dockable factory that controls creation of the RSS News
     // window.
     DockStation.getDockStation().registerDockableFactory(
       VIEW_ID, new NewsDockableFactory()
     );
     
     getPreferences(); // Force prefs to be defaulted if they don't exist
     
     // Register UI for the preferences dialog.
     Ide.getSettings().registerUI( 
       new Navigable( _res.getRes( "PreferencesName" ), 
       NewsFeedPreferencesPanel.class ) );
     
     // The controller is responsible for determining whether items are 
     // enabled or disabled. You can also use a controller to perform operations
     // but in this extension, we choose not to do this. Instead each operation
     // has a class following the command pattern that carries out the operation
     NewsFeedController controller = new NewsFeedController();
     
     createAction( controller, Commands.VIEW_NEWS_DOCKABLE, 
       "org.robsite.extension.rss.ViewNewsDockableCommand", 
       _res.getRes( "CheckRSSNews" ),
       _res.getRes( "CheckRSSNewsMnemonic" ).charAt( 0 )
     );
     
     createAction( controller, Commands.VIEW_NEWS_DOCKABLE_VIEW,
       "org.robsite.extension.rss.ViewNewsDockableCommand",
       _res.getRes( "RSSNews" ),
       _res.getRes( "RSSNewsMnemonic" ).charAt( 0 )
     );
 
     createAction( controller, Commands.MARK_AS_READ, 
       "org.robsite.extension.rss.MarkAsReadCommand",
       _res.getRes( "MarkAsRead" ),
       _res.getRes( "MarkAsReadMnemonic" ).charAt( 0 )
     );
     
     createAction( controller, Commands.OPEN_IN_BROWSER, 
       "org.robsite.extension.rss.OpenInBrowserCommand",
       _res.getRes( "OpenInBrowser" ),
       _res.getRes( "OpenInBrowserMnemonic" ).charAt( 0 )
     );    
 
     // Install an item into the Help menu in the same section as the
     // existing "Check for Updates" item.
     Ide.getMenubar().add( 
       Ide.getMenubar().createMenuItem( 
         Commands.getAction( Commands.VIEW_NEWS_DOCKABLE ) 
       ),
       Environment.getJMenu( Ide.getMainWindow().MENU_HELP ),
       MenuConstants.SECTION_HELP_UPDATES
     );
     
     // Install an item into the View menu in the section set aside for 
     // extensions.
     Ide.getMenubar().add(
       Ide.getMenubar().createMenuItem( 
         Commands.getAction( Commands.VIEW_NEWS_DOCKABLE_VIEW ) 
       ),
       Environment.getJMenu( Ide.getMainWindow().MENU_VIEW ),
       MenuConstants.SECTION_VIEW_ADDINS
     );    
     
     // This is the standard mechanism for delaying some initialization until
     // after all other addins have initialized. It's a good idea to do this
     // if you are starting a thread, since it prevents your thread from 
     // slowing down the initialization of other addins (and hence the
     // overall startup time of the IDE). In debug builds of JDeveloper, 
     // diagnostics will yell loudly at you if you try to create a thread
     // in your initialize() method.
     Ide.addIdeListener( new IdeListener() {
       public void mainWindowClosing( IdeEvent ideEvent ) {}
       public void mainWindowOpened( IdeEvent ideEvent ) 
       {
         try
         {
           _checkRunnable =  new NewsCheckRunnable( NewsFeedExtension.this );
           Thread t = new Thread( _checkRunnable, "RSS News Check Thread" );
           t.start();
           
           // If the preference to check automatically on startup is set,
           // force a check right now.
           if ( getPreferences().isCheckOnStartup() )
           {
             _checkRunnable.forceUpdate();
           }
           
           restartTimer();
           
           // Finally, attach a listener to preferences so that the timer 
           // is reset whenever they change.
           getPreferences().addChangeListener( new ChangeListener() {
             public void stateChanged( ChangeEvent ce )
             {
               restartTimer();
               // Always force an update after changing preferences. This ensures
               // that any new channels get populated now (rather than during
               // the next timer tick, which could be 10 minutes away)
               _checkRunnable.forceUpdate();
             }
           });
         }
         finally
         {
           // We don't care about any more events
           Ide.removeIdeListener( this );
         }
       }
       public void addinsLoaded( IdeEvent ideEvent ) {}
     });
 
   }
   
   public void shutdown()
   {
     s_instance = null;
   }
 
   public float version()
   {
     // Since JDev 9.0.5.1, this value is now being displayed in the Extensions
     // panel off the Help dialog.
     return 9.0517f;
   }
 
   public float ideVersion()
   {
     // This value is not used at all by modern versions of JDeveloper.
     return 0;
   }
 
   public boolean canShutdown()
   {
     return true;
   }  
   
 /// Utilities
 
   
   /***
    * Utility method to create and register an IDE action.
    * 
    * @param controller the controller to associate with the action
    * @param id the command name for the action.
    * @param commandClass the command class for the action.
    * @param label the label for the action.
    * @param mnemonic the mnemonic for the action.
    */
   private void createAction( 
     Controller controller, String id, String commandClass, String label, 
     int mnemonic )
   {
     // Be sure to always use IdeAction.get() instead of IdeAction.create().
     // The main difference is that get() actually remembers your action
     // in the IDE, enabling certain functionality like accelerators to work
     // properly. If you just use IdeAction.create(), your actions are created
     // transiently and not remembered by the IDE.
     IdeAction.get( 
       Commands.id( id ),
       commandClass,
       label,
       null,
       new Integer( mnemonic ),
       null,
       null,
       true
     ).addController( controller );
   }
 }