package org.robotlegs.utilities.remote {
import flash.events.NetStatusEvent;
import flash.events.SecurityErrorEvent;
import flash.net.NetConnection;
import flash.net.ObjectEncoding;
import flash.net.Responder;
import flash.utils.Dictionary;

public class NetConnectionServiceBase implements INetConnectionService {

    protected var netConnections:Dictionary;
    protected var promises:Array;

    public function NetConnectionServiceBase() {
        netConnections = new Dictionary();
        promises = []
    }

    public function call(gatewayUrl:String, remoteMethod:String, ...rest):Promise {
        var nc:NetConnection = getNetConnection(gatewayUrl);
        var p:Promise = request(nc, remoteMethod, rest);
        nc.addEventListener(NetStatusEvent.NET_STATUS, createHandler(handleNetStatus,p), false, 0, true);
        nc.addEventListener(SecurityErrorEvent.SECURITY_ERROR, createHandler(handleSecurityError,p), false, 0, true);
        return p;
    }

    private function getNetConnection(gatewayUrl:String):NetConnection {
        if(netConnections[gatewayUrl])
            return netConnections[gatewayUrl];
        else {
            var nc:NetConnection = new NetConnection();
		    nc.objectEncoding = ObjectEncoding.AMF3;
            nc.connect(gatewayUrl);
            netConnections[gatewayUrl] = nc;
            return nc;
        }
    }

    public function closeConnection(gatewayUrl:String) : void {
        if(netConnections[gatewayUrl]) {
            (netConnections[gatewayUrl] as NetConnection).close();
            delete netConnections[gatewayUrl];
        }
    }

    protected function request(nc:NetConnection, rm:String, params:Array):Promise {
        var p:Promise = new Promise;

        var res:Responder = new Responder(createHandler(handleComplete, p), createHandler(handleIoError, p));
        nc.call.apply(this, [rm, res].concat(params));

        promises.push(p);
        return p;
    }

    protected function releasePromise(promise:Promise):void {
        var index:int = promises.indexOf(promise);
        if (index != -1) {
            promises.splice(index, 1);
        }
    }


    /* ----------- HANDLERS ----------- */

    private function handleNetStatus(e:Object, promise:Promise):void {
        switch (e.info.code) {
            case "NetConnection.Call.Failed":
                releasePromise(promise);
                promise.handleFault({ error: "NetConnection Error", message: 'NetConnection call failed' });
                break;
            case "NetConnection.Connect.Failed":
                releasePromise(promise);
                promise.handleFault({ error: "NetConnection Error", message: 'NetConnection connect failed' });
                break;
        }
    }

    private function handleSecurityError(e:Object, promise:Promise):void {
        releasePromise(promise);
        promise.handleFault({ error: "Security Error", message: String(e.text) });
    }

    protected function handleIoError(e:Object, promise:Promise):void {
        releasePromise(promise);
        promise.handleFault({ error: "IO Error", message: String(e.faultString + " ON " + e.faultDetail + " " + e.faultCode) });
    }

    protected function handleComplete(r:Object, promise:Promise):void {
        releasePromise(promise);
        promise.handleResult( generateObject( r ) );
    }
    /* ----------- END HANDLERS ----------- */

    protected function createHandler(listener:Function, promise:Promise):Function {
        return function(obj:Object):void {
            listener(obj, promise);
        }
    }

    protected function generateObject(data:*):Object {
        return Object(data);
    }
}
}