/*
 * Copyright (c) 2009-2010 Digital Bazaar, Inc. All rights reserved.
 * 
 * @author Dave Longley
 */
package
{
   import flash.display.Sprite;
   
   /**
    * A SocketPool is a flash object that can be embedded in a web page to
    * allow javascript access to pools of Sockets.
    * 
    * Javascript can create a pool and then as many Sockets as it desires. Each
    * Socket will be assigned a unique ID that allows continued javascript
    * access to it. There is no limit on the number of persistent socket
    * connections.
    */
   public class SocketPool extends Sprite
   {
      import flash.events.Event;
      import flash.events.EventDispatcher;
      import flash.errors.IOError;
      import flash.events.IOErrorEvent;
      import flash.events.ProgressEvent;
      import flash.events.SecurityErrorEvent;
      import flash.events.TextEvent;
      import flash.external.ExternalInterface;
      import flash.net.SharedObject;
      import flash.system.Security;
      import flash.utils.ByteArray;
      import mx.utils.Base64Decoder;
      import mx.utils.Base64Encoder;
      
      // a map of ID to Socket
      private var mSocketMap:Object;
      
      // a counter for Socket IDs (Note: assumes there will be no overflow)
      private var mNextId:uint;
      
      // an event dispatcher for sending events to javascript
      private var mEventDispatcher:EventDispatcher;
      
      /**
       * Creates a new, unitialized SocketPool.
       * 
       * @throws Error - if no external interface is available to provide
       *                 javascript access.
       */
      public function SocketPool()
      {
         if(!ExternalInterface.available)
         {
            trace("ExternalInterface is not available");
            throw new Error(
               "Flash's ExternalInterface is not available. This is a " +
               "requirement of SocketPool and therefore, it will be " +
               "unavailable.");
         }
         else
         {
            try
            {
               // set up javascript access:
               
               // initializes/cleans up the SocketPool
               ExternalInterface.addCallback("init", init);
               ExternalInterface.addCallback("cleanup", cleanup);
               
               // creates/destroys a socket
               ExternalInterface.addCallback("create", create);
               ExternalInterface.addCallback("destroy", destroy);
               
               // connects/closes a socket
               ExternalInterface.addCallback("connect", connect);
               ExternalInterface.addCallback("close", close);
               
               // checks for a connection
               ExternalInterface.addCallback("isConnected", isConnected);
               
               // sends/receives data over the socket
               ExternalInterface.addCallback("send", send);
               ExternalInterface.addCallback("receive", receive);
               
               // gets the number of bytes available on a socket
               ExternalInterface.addCallback(
                  "getBytesAvailable", getBytesAvailable);
               
               // add a callback for subscribing to socket events
               ExternalInterface.addCallback("subscribe", subscribe);
               
               // add callbacks for deflate/inflate
               ExternalInterface.addCallback("deflate", deflate);
               ExternalInterface.addCallback("inflate", inflate);
               
               // add callbacks for local disk storage
               ExternalInterface.addCallback("setItem", setItem);
               ExternalInterface.addCallback("getItem", getItem);
               ExternalInterface.addCallback("removeItem", removeItem);
               ExternalInterface.addCallback("clearItems", clearItems);
               
               // socket pool is now ready
               ExternalInterface.call("window.forge.socketPool.ready");
            }
            catch(e:Error)
            {
               log("error=" + e.errorID + "," + e.name + "," + e.message);
               throw e;
            }
            
            log("ready");
         }
      }
      
      /**
       * A debug logging function.
       * 
       * @param obj the string or error to log.
       */
      CONFIG::debugging
      private function log(obj:Object):void
      {
         if(obj is String)
         {
            var str:String = obj as String;
            ExternalInterface.call("console.log", "SocketPool", str);
         }
         else if(obj is Error)
         {
            var e:Error = obj as Error;
            log("error=" + e.errorID + "," + e.name + "," + e.message);
         }
      }
      
      CONFIG::release
      private function log(obj:Object):void
      {
         // log nothing in release mode
      }
      
      /**
       * Called by javascript to initialize this SocketPool.
       * 
       * @param options:
       *        marshallExceptions: true to pass exceptions to and from
       *           javascript.
       */
      private function init(... args):void
      {
         log("init()");
         
         // get options from first argument
         var options:Object = args.length > 0 ? args[0] : null;
         
         // create socket map, set next ID, and create event dispatcher
         mSocketMap = new Object();
         mNextId = 1;
         mEventDispatcher = new EventDispatcher();
         
         // enable marshalling exceptions if appropriate
         if(options != null &&
            "marshallExceptions" in options &&
            options.marshallExceptions === true)
         {
            try
            {
               // Note: setting marshallExceptions in IE, even inside of a
               // try-catch block will terminate flash. Don't set this on IE.
               ExternalInterface.marshallExceptions = true;
            }
            catch(e:Error)
            {
               log(e);
            }
         }
         
         log("init() done");
      }
      
      /**
       * Called by javascript to clean up a SocketPool.
       */
      private function cleanup():void
      {
         log("cleanup()");
         
         mSocketMap = null;
         mNextId = 1;
         mEventDispatcher = null;
         
         log("cleanup() done");
      }
      
      /**
       * Handles events.
       * 
       * @param e the event to handle.
       */
      private function handleEvent(e:Event):void
      {
         // dispatch socket event
         var message:String = (e is TextEvent) ? (e as TextEvent).text : null;
         mEventDispatcher.dispatchEvent(
            new SocketEvent(e.type, e.target as PooledSocket, message));
      }
      
      /**
       * Called by javascript to create a Socket.
       * 
       * @return the Socket ID.
       */
      private function create():String
      {
         log("create()");
         
         // create a Socket
         var id:String = "" + mNextId++;
         var s:PooledSocket = new PooledSocket();
         s.id = id;
         s.addEventListener(Event.CONNECT, handleEvent);
         s.addEventListener(Event.CLOSE, handleEvent);
         s.addEventListener(ProgressEvent.SOCKET_DATA, handleEvent);
         s.addEventListener(IOErrorEvent.IO_ERROR, handleEvent);
         s.addEventListener(SecurityErrorEvent.SECURITY_ERROR, handleEvent);
         mSocketMap[id] = s;
         
         log("socket " + id + " created");
         log("create() done");
         
         return id;
      }
      
      /**
       * Called by javascript to clean up a Socket.
       * 
       * @param id the ID of the Socket to clean up.
       */
      private function destroy(id:String):void
      {
         log("destroy(" + id + ")");
         
         if(id in mSocketMap)
         {
            // remove Socket
            delete mSocketMap[id];
            log("socket " + id + " destroyed");
         }
         
         log("destroy(" + id + ") done");
      }
      
      /**
       * Connects the Socket with the given ID to the given host and port,
       * using the given socket policy port.
       *
       * @param id the ID of the Socket.
       * @param host the host to connect to.
       * @param port the port to connect to.
       * @param spPort the security policy port to use, 0 to use a url.
       * @param spUrl the http URL to the policy file to use, null for default.
       */
      private function connect(
         id:String, host:String, port:uint, spPort:uint,
         spUrl:String = null):void
      {
         log("connect(" +
            id + "," + host + "," + port + "," + spPort + "," + spUrl + ")");
         
         if(id in mSocketMap)
         {
            // get the Socket
            var s:PooledSocket = mSocketMap[id];
            
            // load socket policy file
            // (permits socket access to backend)
            if(spPort !== 0)
            {
               spUrl = "xmlsocket://" + host + ":" + spPort;
               log("using cross-domain url: " + spUrl);
               Security.loadPolicyFile(spUrl);
            }
            else if(spUrl !== null && typeof(spUrl) !== undefined)
            {
               log("using cross-domain url: " + spUrl);
               Security.loadPolicyFile(spUrl);
            }
            else
            {
               log("not loading any cross-domain url");
            }
            
            // connect
            s.connect(host, port);
         }
         else
         {
            // no such socket
            log("socket " + id + " does not exist");
         }
         
         log("connect(" + id + ") done");
      }
      
      /**
       * Closes the Socket with the given ID.
       *
       * @param id the ID of the Socket.
       */
      private function close(id:String):void
      {
         log("close(" + id + ")");
         
         if(id in mSocketMap)
         {
            // close the Socket
            var s:PooledSocket = mSocketMap[id];
            if(s.connected)
            {
               s.close();
            }
         }
         else
         {
            // no such socket
            log("socket " + id + " does not exist");
         }
         
         log("close(" + id + ") done");
      }
      
      /**
       * Determines if the Socket with the given ID is connected or not.
       *
       * @param id the ID of the Socket.
       *
       * @return true if the socket is connected, false if not.
       */
      private function isConnected(id:String):Boolean
      {
         var rval:Boolean = false;
         log("isConnected(" + id + ")");
         
         if(id in mSocketMap)
         {
            // check the Socket
            var s:PooledSocket = mSocketMap[id];
            rval = s.connected;
         }
         else
         {
            // no such socket
            log("socket " + id + " does not exist");
         }
         
         log("isConnected(" + id + ") done");
         return rval;
      }
      
      /**
       * Writes bytes to a Socket.
       *
       * @param id the ID of the Socket.
       * @param bytes the string of base64-encoded bytes to write.
       *
       * @return true on success, false on failure. 
       */
      private function send(id:String, bytes:String):Boolean
      {
         var rval:Boolean = false;
         log("send(" + id + ")");
         
         if(id in mSocketMap)
         {
         	// write bytes to socket
            var s:PooledSocket = mSocketMap[id];
            try
            {
               var b64:Base64Decoder = new Base64Decoder();
               b64.decode(bytes);
               var b:ByteArray = b64.toByteArray();
               s.writeBytes(b, 0, b.length);
               s.flush();
               rval = true;
            }
            catch(e:IOError)
            {
               log(e);
               
               // dispatch IO error event
               mEventDispatcher.dispatchEvent(new SocketEvent(
                  IOErrorEvent.IO_ERROR, s, e.message));
               if(s.connected)
               {
                  s.close();
               }
            }
         }
         else
         {
            // no such socket
            log("socket " + id + " does not exist");
         }
         
         log("send(" + id + ") done");
         return rval;
      }
      
      /**
       * Receives bytes from a Socket.
       *
       * @param id the ID of the Socket.
       * @param count the maximum number of bytes to receive.
       *
       * @return an object with 'rval' set to the received bytes,
       *         base64-encoded, or set to null on error.
       */
      private function receive(id:String, count:uint):Object
      {
      	 var rval:String = null;
         log("receive(" + id + "," + count + ")");
         
         if(id in mSocketMap)
         {
         	// only read what is available
            var s:PooledSocket = mSocketMap[id];
            if(count > s.bytesAvailable)
            {
               count = s.bytesAvailable;
            }
            
            try
            {
               // read bytes from socket
               var b:ByteArray = new ByteArray();
               s.readBytes(b, 0, count);
               b.position = 0;
               var b64:Base64Encoder = new Base64Encoder();
               b64.insertNewLines = false;
               b64.encodeBytes(b, 0, b.length);
               rval = b64.toString();
            }
            catch(e:IOError)
            {
               log(e);
               
               // dispatch IO error event
               mEventDispatcher.dispatchEvent(new SocketEvent(
                  IOErrorEvent.IO_ERROR, s, e.message));
               if(s.connected)
               {
                  s.close();
               }
            }
         }
         else
         {
            // no such socket
            log("socket " + id + " does not exist");
         }
         
         log("receive(" + id + "," + count + ") done");
         return {rval: rval};
      }
      
      /**
       * Gets the number of bytes available from a Socket.
       *
       * @param id the ID of the Socket.
       *
       * @return the number of available bytes.
       */
      private function getBytesAvailable(id:String):uint
      {
         var rval:uint = 0;
         log("getBytesAvailable(" + id + ")");
         
         if(id in mSocketMap)
         {
            var s:PooledSocket = mSocketMap[id];
            rval = s.bytesAvailable;
         }
         else
         {
            // no such socket
            log("socket " + id + " does not exist");
         }
         
         log("getBytesAvailable(" + id +") done");
         return rval;
      }      
      
      /**
       * Registers a javascript function as a callback for an event.
       * 
       * @param eventType the type of event (socket event types).
       * @param callback the name of the callback function.
       */
      private function subscribe(eventType:String, callback:String):void
      {
         log("subscribe(" + eventType + "," + callback + ")");
         
         switch(eventType)
         {
            case Event.CONNECT:
            case Event.CLOSE:
            case IOErrorEvent.IO_ERROR:
            case SecurityErrorEvent.SECURITY_ERROR:
            case ProgressEvent.SOCKET_DATA:
            {
               log(eventType + " => " + callback);
               mEventDispatcher.addEventListener(
                  eventType, function(event:SocketEvent):void
               {
                  log("event dispatched: " + eventType);
                  
                  // build event for javascript
                  var e:Object = new Object();
                  e.id = event.socket ? event.socket.id : 0;
                  e.type = eventType;
                  if(event.socket && event.socket.connected)
                  {
                     e.bytesAvailable = event.socket.bytesAvailable;
                  }
                  else
                  {
                     e.bytesAvailable = 0;
                  }
                  if(event.message)
                  {
                     e.message = event.message;
                  }
                  
                  // send event to javascript
                  ExternalInterface.call(callback, e);
               });
               break;
            }
            default:
               throw new ArgumentError(
                  "Could not subscribe to event. " +
                  "Invalid event type specified: " + eventType);
         }
         
         log("subscribe(" + eventType + "," + callback + ") done");
      }
      
      /**
       * Deflates the given data.
       * 
       * @param data the base64-encoded data to deflate.
       * 
       * @return an object with 'rval' set to deflated data, base64-encoded.
       */
      private function deflate(data:String):Object
      {
         log("deflate");
         
         var b64d:Base64Decoder = new Base64Decoder();
         b64d.decode(data);
         var b:ByteArray = b64d.toByteArray();
         b.compress();
         b.position = 0;
         var b64e:Base64Encoder = new Base64Encoder();
         b64e.insertNewLines = false;
         b64e.encodeBytes(b, 0, b.length);
         
         log("deflate done");
         return {rval: b64e.toString()};
      }
      
      /**
       * Inflates the given data.
       * 
       * @param data the base64-encoded data to inflate.
       * 
       * @return an object with 'rval' set to the inflated data,
       *         base64-encoded, null on error.
       */
      private function inflate(data:String):Object
      {
         log("inflate");
         var rval:Object = {rval: null};
      	 
      	 try
      	 {
            var b64d:Base64Decoder = new Base64Decoder();
            b64d.decode(data);
            var b:ByteArray = b64d.toByteArray();
            b.uncompress();
            b.position = 0;
            var b64e:Base64Encoder = new Base64Encoder();
            b64e.insertNewLines = false;
            b64e.encodeBytes(b, 0, b.length);
            rval.rval = b64e.toString();
         }
         catch(e:Error)
         {
         	log(e);
            rval.error = {
                id: e.errorID,
                name: e.name,
                message: e.message
            };
         }
         
         log("inflate done");
         return rval;
      }
      
      /**
       * Stores an item with a key and arbitrary base64-encoded data on local
       * disk.
       * 
       * @param key the key for the item.
       * @param data the base64-encoded item data.
       * @param storeId the storage ID to use, defaults to "forge.storage".
       * 
       * @return an object with rval set to true on success, false on failure
       *         with error included.
       */
      private function setItem(
         key:String, data:String, storeId:String = "forge.storage"):Object
      {
         var rval:Object = {rval: false};
         try
         {
            var store:SharedObject = SharedObject.getLocal(storeId);
            if(!('keys' in store.data))
            {
               store.data.keys = {};
            }
            store.data.keys[key] = data;
            store.flush();
            rval.rval = true;
         }
         catch(e:Error)
         {
         	log(e);
         	rval.error = {
                id: e.errorID,
                name: e.name,
                message: e.message
            };
         }
         return rval;
      }
      
      /**
       * Gets an item from the local disk.
       * 
       * @param key the key for the item.
       * @param storeId the storage ID to use, defaults to "forge.storage".
       * 
       * @return an object with rval set to the item data (which may be null),
       *         check for error object if null.
       */
      private function getItem(
         key:String, storeId:String = "forge.storage"):Object
      {
         var rval:Object = {rval: null};
         try
         {
            var store:SharedObject = SharedObject.getLocal(storeId);
            if('keys' in store.data && key in store.data.keys)
            {
               rval.rval = store.data.keys[key];
            }
         }
         catch(e:Error)
         {
         	log(e);
            rval.error = {
                id: e.errorID,
                name: e.name,
                message: e.message
            };
         }
         return rval;
      }
      
      /**
       * Removes an item from the local disk.
       * 
       * @param key the key for the item.
       * @param storeId the storage ID to use, defaults to "forge.storage".
       * 
       * @return an object with rval set to true if removed, false if not.
       */
      private function removeItem(
         key:String, storeId:String = "forge.storage"):Object
      {
         var rval:Object = {rval: false};
         try
         {
            var store:SharedObject = SharedObject.getLocal(storeId);
            if('keys' in store.data && key in store.data.keys)
            {
               delete store.data.keys[key];
               
               // clean up storage entirely if empty
               var empty:Boolean = true;
               for(var prop:String in store.data.keys)
               {
                  empty = false;
                  break;
               }
               if(empty)
               {
                  store.clear();
               }
               rval.rval = true;
            }
         }
         catch(e:Error)
         {
            log(e);
            rval.error = {
                id: e.errorID,
                name: e.name,
                message: e.message
            };
         }
         return rval;
      }
      
      /**
       * Clears an entire store of all of its items.
       * 
       * @param storeId the storage ID to use, defaults to "forge.storage".
       * 
       * @return an object with rval set to true if cleared, false if not.
       */
      private function clearItems(storeId:String = "forge.storage"):Object
      {
         var rval:Object = {rval: false};
         try
         {
            var store:SharedObject = SharedObject.getLocal(storeId);
            store.clear();
            rval.rval = true;
         }
         catch(e:Error)
         {
            log(e);
            rval.error = {
                id: e.errorID,
                name: e.name,
                message: e.message
            };
         }
         return rval;
      }
   }
}