//---------------------------------------------------------------------------------
//  (c) 2006 Enfotrust Networks, Inc
//---------------------------------------------------------------------------------
  
CreateNamespace ( "Gutenberg" );

Gutenberg = 
{
  Message : function ( MessageType, MessageDelay, MessageData )
  {
    this.MessageType = MessageType;
    this.MessageDelay = MessageDelay;
    this.Message = MessageData;
    
  },
  
  Subscriber : function ( MessageType, Callback )
  {
    this.MessageType = MessageType;
    this.Callback = Callback;
  },
  
  Messages : 
  {
    Add : function ( Message )
    {
      this.List.push ( Message );
    },

    Count : function ( )
    {
      return this.List.length;
    },

    GetFirstMessage : function ( )
    {
      FirstMessage = this.List.shift ( );
      return FirstMessage;
    },

    GetMessage : function ( Index, Interval )
    {
      var Message = this.List[ Index ];
      Message.MessageDelay -= Interval;
      if ( Message.MessageDelay > 0 )
      {
          this.List[ Index ] = Message;
          return null;
      }
      else
      {
          return Message;
      }
    },
    
    Remove : function ( MessageType )
    {
      var ItemsInList = this.List.length;
      var ItemCount = 0;
      
      while ( ItemCount < ItemsInList )
      {
        var Message = this.List.shift ( );
        if ( Message.MessageType != MessageType )
        {
          this.List.push ( Message );
        }
        else
        {
         // Gutenberg.PublishNow("LogThis","Removed: " + Message.MessageType + " " + Message.Message );
        }
          
        ItemCount++;
      }
    },

    ClearOld : function()
    {
      var ItemsInList = this.List.length;
      var ItemCount = 0;
      
      while ( ItemCount < ItemsInList )
      {
        var Message = this.List.shift ( );
        if ( Message.MessageDelay > 0 )
        {
          this.List.push ( Message );
        }
          
        ItemCount++;
      }
    }
  },
  
  Subscribers :
  {

    Exists : function ( MessageType , Callback )
    {
    
      var l = this.List.length;
      for ( var Loop = 0; Loop < l; Loop++ )
      {
        if (( this.List[ Loop ].MessageType == MessageType ) && 
        ( this.List[ Loop ].Callback == Callback ))
        {
          return true;
        }    
      }    
      return false;
    },

    Add : function ( MessageType, Callback )
    {
      var NewSubscriber = new Gutenberg.Subscriber ( MessageType , Callback );
      if ( this.Exists ( MessageType, Callback ) == false )
      {
        this.List.push ( NewSubscriber );
      }
      
    },
    
    Remove : function (  MessageType, Callback )
    {
      var ItemsInList = this.List.length;
      var ItemCount = 0;
     
      while ( ItemCount < ItemsInList )
      {
        var subscriber = this.List.shift ( );
        if ( subscriber.MessageType != MessageType )
        {
          this.List.push ( subscriber );
        }
        else
        {
          if ( subscriber.Callback != Callback )
          {
            this.List.push ( subscriber );
          }
        }
          
        ItemCount++;
      }
    },
    
    

    ProcessMessage : function ( Message )
    {
    
      var l = this.List.length;
      for ( var Loop = 0 ; Loop < l ; Loop++ )
      {
        if (this.List[Loop] != null)
        {
        if ( Message.MessageType == this.List[ Loop ].MessageType )
        {
			    try
			    {
			      if ( this.List[ Loop ].Callback != null )
			      {
			        this.List[ Loop ].Callback ( Message.Message );
			      }
			      else
			      {
              alert ( 'Missing Gutenberg Callback for ' + Message.MessageType );  			    
			      }
			    }

			    catch ( e )
			    {
			       alert ( 
		          "ERROR    : Callback Error\r\n" + 
		          "ERROR MSG: " + e.message + "\r\n" +
		          "MESSAGE  : " + Message.MessageType + "\r\n" + 
		          "FUNCTION : " + this.List[Loop].Callback.toString());
			    }
        }
        }
      }
    }
  },
  
  Publish : function ( MessageType , MessageDelay , MessageData )
  {
    
    if ( MessageType != "LOGTHIS")
    {
      if ( typeof(MessageData) == "object" )
        {
          try
          {
            //this.PublishNow ( "LogThis" , "Publishing:"  + MessageType + " - " + MessageData.ToString());
          }
          catch ( Event )
          {
           // this.PublishNow("LogThis","Publishing:" + MessageType + " - " + MessageData);
          }
        }
        else
        {
          //this.PublishNow("LogThis","Publishing:" + MessageType + " - " + MessageData);
        }
    }
    
    this.Messages.Add ( new Gutenberg.Message( MessageType , MessageDelay, MessageData ) );
  },
  
  PublishSingle : function ( MessageType, MessageDelay, MessageData )
  {
    this.Messages.Remove ( MessageType );
    this.Publish ( MessageType, MessageDelay, MessageData );
    //remove messages of this type and the put it on the queue.
  },

  PublishNow : function ( MessageType, MessageData )
  {

    if ( MessageType != "LogThis")
    {
        if ( typeof(MessageData) == "object" )
        {
          try
          {
            //this.PublishNow ( "LogThis" , "Publishing Now:" + MessageType + " - " + MessageData.ToString());
          }
          catch ( Event )
          {
           // this.PublishNow("LogThis","Publishing Now:" + MessageType + " - " + MessageData);
          }
        }
        else
        {
         // this.PublishNow("LogThis","Publishing Now:" + MessageType + " - " + MessageData);
        }
    }
    
    this.Subscribers.ProcessMessage( new this.Message ( MessageType , 0, MessageData ) );
  },

  Subscribe : function( MessageType, Callback )
  {

    //this.PublishNow ( "LogThis","Subscribing:" + MessageType) ;

    this.Subscribers.Add ( MessageType , Callback );
  },

  Unsubscribe : function ( MessageType, Callback )
  {
    this.Subscribers.Remove ( MessageType , Callback );  
  },

  Start : function( Interval )
  {
    this.Timer = setInterval ( 'Gutenberg.Run()' , Interval );
  },

  Stop : function ()
  {
    clearInterval ( this.Timer );
  },

  Run : function ()
  {
    for ( Loop = 0 ; Loop < this.Messages.Count() ; Loop++ )
    {
        var Message = this.Messages.GetMessage( Loop , this.Interval );
        if ( Message != null )
        {
                this.Subscribers.ProcessMessage ( Message );
        }
    }
    
    this.Messages.ClearOld ( );
  } 
}

Gutenberg.Subscribers.List = new Array();
Gutenberg.Messages.List = new Array ( );