////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You 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 mx.messaging.channels
{

import flash.events.Event;
import flash.events.HTTPStatusEvent;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.events.SecurityErrorEvent;
import flash.events.StatusEvent;
import flash.utils.ByteArray;

import mx.core.mx_internal;
import mx.logging.Log;
import mx.messaging.FlexClient;
import mx.messaging.config.ConfigMap;
import mx.messaging.config.ServerConfig;
import mx.messaging.events.ChannelFaultEvent;
import mx.messaging.events.MessageEvent;
import mx.messaging.messages.AbstractMessage;
import mx.messaging.messages.AsyncMessage;
import mx.messaging.messages.ErrorMessage;
import mx.messaging.messages.IMessage;
import mx.resources.IResourceManager;
import mx.resources.ResourceManager;

use namespace mx_internal;

[ResourceBundle("messaging")]

/**
 *  The StreamingHTTPChannel class provides support for messaging and
 *  offers a different push model than the base HTTPChannel. Rather than
 *  polling for data from the server, the streaming channel opens an internal
 *  HTTP connection to the server that is held open to allow the server to
 *  stream data down to the client with no poll overhead.
 *
 *  <p>
 *  Messages sent by this channel to the server are sent using a URLLoader
 *  which uses an HTTP connection internally for the duration of the operation.
 *  Once the message is sent and an acknowledgement or fault is returned the HTTP connection
 *  used by URLLoader is released by the channel. These client-to-server messages are
 *  not sent over the streaming HTTP connection that the channel holds open to receive
 *  server pushed data.
 *  </p>
 *
 *  <p>
 *  Although this class extends the base HTTPChannel to inherit the regular HTTP
 *  handling, it does not support polling.
 *  </p>
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion BlazeDS 4
 *  @productversion LCDS 3 
 */
public class StreamingHTTPChannel extends HTTPChannel
{
    //--------------------------------------------------------------------------
    //
    // Constructor
    //
    //--------------------------------------------------------------------------

    /**
     *  Constructor.
     *
     *  @param id The id of this Channel.
     *
     *  @param uri The uri for this Channel.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion BlazeDS 4
     *  @productversion LCDS 3 
     */
    public function StreamingHTTPChannel(id:String = null, uri:String = null)
    {
        super(id, uri);

        // Disable polling.
        internalPollingEnabled = false;
    }

    //--------------------------------------------------------------------------
    //
    // Variables
    //
    //--------------------------------------------------------------------------

      /**
       * Helper class used by the channel to establish a streaming HTTP connection
       * with the server.
       *  
       *  @langversion 3.0
       *  @playerversion Flash 9
       *  @playerversion AIR 1.1
       *  @productversion BlazeDS 4
       *  @productversion LCDS 3 
       */
    private var streamingConnectionHandler:StreamingConnectionHandler;

    /**
     *  @private
     */
    private var resourceManager:IResourceManager =
                                    ResourceManager.getInstance();

    //--------------------------------------------------------------------------
    //
    // Properties
    //
    //--------------------------------------------------------------------------

    //----------------------------------
    //  pollingEnabled
    //----------------------------------

    /**
     *  @private
     */
    override public function set pollingEnabled(value:Boolean):void
    {
        var message:String = resourceManager.getString(
            "messaging", "pollingNotSupportedHTTP");
        throw new Error(message);
    }

    //----------------------------------
    //  pollingInterval
    //----------------------------------

    /**
     *  @private
     */
    override public function set pollingInterval(value:Number):void
    {
        var message:String = resourceManager.getString(
            "messaging", "pollingNotSupportedHTTP");
        throw new Error(message);
    }

    //----------------------------------
    //  realtime
    //----------------------------------

    /**
     *  @private
     *  Returns true since streaming channels are considered realtime.
     */
    override mx_internal function get realtime():Boolean
    {
        return true;
    }

    //--------------------------------------------------------------------------
    //
    // Overridden Public Methods
    //
    //--------------------------------------------------------------------------

    /**
     *  Polling is not supported by this channel.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion BlazeDS 4
     *  @productversion LCDS 3 
     */
    override public function poll():void
    {
        var message:String = resourceManager.getString(
            "messaging", "pollingNotSupportedHTTP");
        throw new Error(message);
    }

    //--------------------------------------------------------------------------
    //
    // Overriden Protected Methods
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     *  Closes the streaming connection before redispatching the fault event.
     *
     *  @param event The ChannelFaultEvent.
     */
    override protected function connectFailed(event:ChannelFaultEvent):void
    {
        if (streamingConnectionHandler != null)
            streamingConnectionHandler.closeStreamingConnection();

        super.connectFailed(event);
    }

    /**
     *  @private
     *  Closes the streaming connection before disconnecting.
     */
    override protected function internalDisconnect(rejected:Boolean = false):void
    {
        if (streamingConnectionHandler != null)
            streamingConnectionHandler.closeStreamingConnection();

        super.internalDisconnect(rejected);
    }

    /**
     *  @private
     *  This method will be called if the ping message sent to test connectivity
     *  to the server during the connection attempt succeeds.
     *  Before triggering connect success handling the streaming channel must set
     *  up its streaming connection with the server.
     */
    override protected function internalPingComplete(msg:AsyncMessage):void
    {
        if (msg != null)
        {
            ServerConfig.updateServerConfigData(msg.body as ConfigMap, endpoint);

            // Set the server assigned FlexClient Id.
            if (FlexClient.getInstance().id == null && msg.headers[AbstractMessage.FLEX_CLIENT_ID_HEADER] != null)
                FlexClient.getInstance().id = msg.headers[AbstractMessage.FLEX_CLIENT_ID_HEADER];
        }
        if (credentials != null && !(msg is ErrorMessage))
            setAuthenticated(true);

        if (streamingConnectionHandler == null)
        {
            streamingConnectionHandler = new StreamingHTTPConnectionHandler(this, _log);
            streamingConnectionHandler.addEventListener(Event.OPEN, streamOpenHandler);
            streamingConnectionHandler.addEventListener(Event.COMPLETE, streamCompleteHandler);
            streamingConnectionHandler.addEventListener(HTTPStatusEvent.HTTP_STATUS, streamHttpStatusHandler);
            streamingConnectionHandler.addEventListener(IOErrorEvent.IO_ERROR, streamIoErrorHandler);
            streamingConnectionHandler.addEventListener(SecurityErrorEvent.SECURITY_ERROR, streamSecurityErrorHandler);
            streamingConnectionHandler.addEventListener(StatusEvent.STATUS, streamStatusHandler);
        }
        streamingConnectionHandler.openStreamingConnection(appendToURL);
    }

    //--------------------------------------------------------------------------
    //
    // Private Methods
    //
    //--------------------------------------------------------------------------

    /**
     *  If the streaming connection receives an open event the channel is setup
     *  and gets ready for messaging.
     *
     *  @param event The OPEN Event.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion BlazeDS 4
     *  @productversion LCDS 3 
     */
    private function streamOpenHandler(event:Event):void
    {
       connectSuccess();
    }

    /**
     *  A complete event indicates that the streaming connection has been closed by the server.
     *  This is a no-op if the channel is disconnected on the client, otherwise notifies the client
     *  channel that it has disconnected.
     *
     *  @param event The COMPLETE Event.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion BlazeDS 4
     *  @productversion LCDS 3 
     */
    private function streamCompleteHandler(event:Event):void
    {
        if (connected) // The server has closed the connection but the client currently believes it should be connected.
        {
            // Dispatch a channel fault event.
            var faultEvent:ChannelFaultEvent = ChannelFaultEvent.createEvent(this, false, "Channel.Stream.Failed", "error", "Remote endpoint has closed the streaming connection.");
            faultEvent.rootCause = event;
            dispatchEvent(faultEvent);
            // And disconnect the channel.
            internalDisconnect();
        }
    }

    /**
     *  Handles HTTP status events dispatched by the streaming connection.
     *
     *  @param event The HTTPStatusEvent.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion BlazeDS 4
     *  @productversion LCDS 3 
     */
    private function streamHttpStatusHandler(event:HTTPStatusEvent):void
    {
        // No-op because most of the times, HTTP status is zero.
        // See ioErrorHandler.
    }

    /**
     *  Handles IO error events dispatched by the streaming connection.
     *
     *  @param event The IOErrorEvent.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion BlazeDS 4
     *  @productversion LCDS 3 
     */
    private function streamIoErrorHandler(event:IOErrorEvent):void
    {
        var faultEvent:ChannelFaultEvent;
        if (connected)
        {
            // Dispatch a channel fault event.
            faultEvent = ChannelFaultEvent.createEvent(this, false, "Channel.Stream.Failed", "error", " url: '" + endpoint + "'");
            faultEvent.rootCause = event;
            dispatchEvent(faultEvent);
            // And disconnect the channel.
            internalDisconnect();
        }
        else
        {
            // Fault the current connect attempt.
            faultEvent = ChannelFaultEvent.createEvent(this, false, "Channel.Stream.Failed", "error", " url: '" + endpoint + "'");
            faultEvent.rootCause = event;
            connectFailed(faultEvent);
        }
    }

    /**
     *  Handles security error events dispatched by the streaming connection.
     *
     *  @param event The SecurityErrorEvent.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion BlazeDS 4
     *  @productversion LCDS 3 
     */
    private function streamSecurityErrorHandler(event:SecurityErrorEvent):void
    {
        // Just log as we'll never reach this handler because the prior ping will trigger
        // a security error before we try to establish the streaming connection.
        if (Log.isDebug())
            _log.debug("'{0}' channel encountered a security error: {1}", id, event.text);
    }

    /**
     *  Handle status events dispatched by the streaming connection.
     *
     *  @param event The StatusEvent.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion BlazeDS 4
     *  @productversion LCDS 3 
     */
    private function streamStatusHandler(event:StatusEvent):void
    {
        // Only a disconnect status event is currently handled.
        if (event.code == StreamingConnectionHandler.DISCONNECT_CODE)
        {
            streamingConnectionHandler.closeStreamingConnection();
            disconnectSuccess(true /* rejected */);
            credentials = null;
        }
    }
}

}

//------------------------------------------------------------------------------
//
// Private Classes
//
//------------------------------------------------------------------------------

import flash.net.ObjectEncoding;
import flash.utils.ByteArray;

import mx.logging.ILogger;
import mx.logging.Log;
import mx.messaging.Channel;
import mx.messaging.channels.StreamingConnectionHandler;
import mx.messaging.channels.amfx.AMFXDecoder;
import mx.messaging.channels.amfx.AMFXContext;
import mx.messaging.messages.IMessage;

/**
 *  A helper class that is used by the streaming channels to open an internal
 *  HTTP connection to the server that is held open to allow the server to
 *  stream data down to the client with no poll overhead.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion BlazeDS 4
 *  @productversion LCDS 3 
 */
class StreamingHTTPConnectionHandler extends StreamingConnectionHandler
{
    //--------------------------------------------------------------------------
    //
    // Constructor
    //
    //--------------------------------------------------------------------------

    /**
     *  Constructor.
     *
     *  @param channel The Channel that uses this class.
     *  @param log Reference to the logger for the associated Channel.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion BlazeDS 4
     *  @productversion LCDS 3 
     */
    public function StreamingHTTPConnectionHandler(channel:Channel, log:ILogger)
    {
        super(channel, log);
    }

    //--------------------------------------------------------------------------
    //
    // Protected Methods
    //
    //--------------------------------------------------------------------------

    /**
     *  Used by the streamProgressHandler to read an AMFX encoded message.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion BlazeDS 4
     *  @productversion LCDS 3 
     */
    override protected function readMessage():IMessage
    {
        var message:IMessage;
        chunkBuffer.position = dataOffset - 1;
        var messageBytes:ByteArray = new ByteArray();
        messageBytes.objectEncoding = ObjectEncoding.AMF3;
        try
        {
            chunkBuffer.readBytes(messageBytes, 0, dataBytesToRead);
            var messageString:String = messageBytes.readUTFBytes(dataBytesToRead);
            var messageObject:Object = AMFXDecoder.decodeValue(XML(messageString), new AMFXContext());
            message = IMessage(messageObject);
        }
        catch(error:Error)
        {
            if (Log.isError())
                _log.error("'{0}' channel encountered an error while reading a message from the streaming connection: {1}", channel.id, error.message);
        }
        return message;
    }
}