/* ***** BEGIN LICENSE BLOCK *****
 *   Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is bandwagon.
 *
 * The Initial Developer of the Original Code is
 * Mozilla Corporation.
 * Portions created by the Initial Developer are Copyright (C) 2008
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s): David McNamara
 *                 Brian King
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

Bandwagon.RPC = new function() {}

Bandwagon.RPC.Service = function()
{
    // keep reference these things in case they go away. (we're in a component - it happens)
    this.Bandwagon = Bandwagon;
    this.Components = Components;

    // private instance variables
    this._observers = new Array();
    this._logger = null;
    this._serviceRootURL = this.Bandwagon.RPC.Constants.BANDWAGON_RPC_BASE_URL;

    this.rpcComplete = function(rpcnet, result, response, type, callback)
    {
        var service = this;

        service._logger.debug("Bandwagon.RPC.Service: got rpc complete (id=" + (rpcnet?rpcnet.id:"null") + ",s=" + (rpcnet?rpcnet.status:"null") + ") of type = " + type + " and status = " + result);

        var event = new service.Bandwagon.RPC.Event(type, result, response);
        event.Bandwagon = service.Bandwagon;

        if (result == service.Bandwagon.RPC.Constants.BANDWAGON_RPC_NET_FAILURE)
        {
            // response is error code
            service._logger.debug("Bandwagon.RPC.Service: complete is error with error code: " + response.errorCode + ", message: " + response.errorMessage)
            event.error = new service.Bandwagon.RPC.Error(response.errorCode, response.errorMessage);
        }

        // CALLBACK TYPE 1: if we have a callback, call it

        if (callback && typeof(callback) == 'function')
        {
            callback(event);
        }

        // CALLBACK TYPE 2: if we have observers, notify them

        service.notifyObservers(event);
    };

    this.rpcCompleteWithError = function(rpcnet, errorCode, type)
    {
        this.rpcComplete(rpcnet, this.Bandwagon.RPC.Constants.BANDWAGON_RPC_RPC_FAILURE, errorCode, type);
    }

    this.notifyObservers = function(event)
    {
        //for (var i=0; i<this._observers.length; i++)
        for (var id in this._observers)
        {
            if (this._observers[id])
            {
                try
                {
                    this._observers[id](event);
                }
                catch (e)
                {
                    this._logger.error("Bandwagon.RPC.Service.onComplete: error notifying observer: " + e);
                    //Bandwagon.Util.dumpObject(e);
                }
            }
        }
   };

    this.rpcSend = function(type, callback, action, method, data, url)
    {
        var service = this;

        var rpcnet = new service.Bandwagon.RPC.Net(service.Bandwagon, service.Components);

        rpcnet.registerLogger(service._logger);
        var isLogin = (type == service.Bandwagon.RPC.Constants.BANDWAGON_RPC_EVENT_TYPE_BANDWAGON_RPC_LOGIN_COMPLETE);
        var actionUrl = (action.match(/^https?:/)?action:(this._serviceRootURL+action));
        service._logger.debug("Bandwagon.RPC.Service: request going to : " + actionUrl);
        rpcnet.setUrl(actionUrl);
        rpcnet.setType(type);

        if (method && method == "POST")
        {
            rpcnet.setMethod("POST");
            rpcnet.setPostData(data);
        }
        else
        {
            rpcnet.setMethod("GET");
            rpcnet.setArguments(data);
        }

        rpcnet.onComplete = function(rpc, result, response, type) { service.rpcComplete(rpc, result, response, type, callback); };

        // send immediately
        service._logger.debug("Bandwagon.RPC.Service: sending rpc immediately");
        rpcnet.send();
    };

    this.createAction = function(action, replacements)
    {
        if (replacements)
        {
            for (var i=0; i<replacements.length; i++)
            {
                action = action.replace("%" + (i+1), encodeURIComponent(replacements[i]));
            }
        }

        return action;
    };

    this.getUniqueId = function()
    {
        var id = ((new Date()).getTime() - 1169730000000) + "" + (Math.round(1000*Math.random())+1000);
        return id;
    };
}

/* 
 * Public Utility Methods
 */

Bandwagon.RPC.Service.prototype.registerLogger = function(logger)
{
    this._logger = logger;
}

Bandwagon.RPC.Service.prototype.registerObserver = function(observer)
{
    var id = this.getUniqueId();

    this._observers[id] = observer;

    this._logger.info('Bandwagon.RPC.Service.registerObserver: adding observer, id = ' + id);

    return id;
}

Bandwagon.RPC.Service.prototype.unregisterObserver = function(observerId)
{
    for (var i in this._observers)
    {
        if (i == observerId)
        {
            this._observers[observerId] = null;
            this._logger.debug('Bandwagon.RPC.Service.unregisterObserver: removed observer, id = ' + observerId);
            return;
        }
    }
}

/*
 * Bandwagon Protocol Methods Below Here
 */

Bandwagon.RPC.Service.prototype.getFeed = function(feed, callback)
{
    var service = this;

    this._logger.debug("Bandwagon.RPC.Service.login: getting updates for feed '" + feed.url +  "' ...");

    feed.status = feed.STATUS_LOADING;

    // TODO feed.password handling goes here
    var data = null;

    var internalCallback = function(event)
    {
        if (event.isError())
        {
            feed.status = feed.STATUS_LOADERROR;
        }
        else
        {
            feed.unserialize(event.getData());
            feed.status = feed.STATUS_LOADED;
        }

        event.feed = feed;

        if (callback)
        {
            callback(event);
        }
    }

    this.rpcSend(service.Bandwagon.RPC.Constants.BANDWAGON_RPC_EVENT_TYPE_BANDWAGON_RPC_GET_FEED_COMPLETE, 
                 internalCallback, 
                 feed.url,
                 "GET",
                 data);
}

Bandwagon.RPC.Service.prototype.subscribeFeed = function(feed, callback)
{
    Bandwagon.Logger.debug("Bandwagon.RPC.Service.subscribeFeed: TBD");

    // TODO

    if (callback)
        callback(new this.Bandwagon.RPC.Event());
}

Bandwagon.RPC.Service.prototype.unsubscribeFeed = function(feed, callback)
{
    Bandwagon.Logger.debug("Bandwagon.RPC.Service.unsubscribeFeed: TBD");

    // TODO

    if (callback)
        callback(new this.Bandwagon.RPC.Event());
}

Bandwagon.RPC.Service.prototype.publishToFeed = function(extension, feed, personalNote, callback)
{
    Bandwagon.Logger.debug("Bandwagon.RPC.Service.publishToFeed: extension.guid = '" + extension.guid + "', extension.name = '" + extension.name + "', feed = '" + feed.url + "', personalNote = '" + personalNote + "'");
    Bandwagon.Logger.debug("Bandwagon.RPC.Service.publishToFeed: TBD");

    // TODO

    if (callback)
    {
        setTimeout(function() { callback(new this.Bandwagon.RPC.Event()) }, 2000);
    }
}

Bandwagon.RPC.Service.prototype.shareToEmail = function(extension, emailAddress, personalNote, callback)
{
    var service = this;

    Bandwagon.Logger.debug("Bandwagon.RPC.Service.publishToFeed: extension.guid = '" + extension.guid + "', extension.name = '" + extension.name + "', emailAddress = '" + emailAddress + "', personalNote = '" + personalNote + "'");

    if (!extension.guid || extension.guid == "" || !emailAddress || emailAddress == "")
    {
        if (callback)
            callback(new this.Bandwagon.RPC.Event());

        return;
    }

    var data = null;

    var data = {
        "guid": extension.guid,
        "emails[0]": emailAddress,
        "message": personalNote
    };

    var internalCallback = function(event)
    {
        if (!event.isError())
        {
            // check for service level errors

            var response = event.getData();

            // success has a body of "<success/>"
            // failure has a body e.g. "<error>Add-on not found!</error>"

            if (response.name() == "success")
            {
                // all ok
            }
            else if (response.name() == "error")
            {
                // "expected" error -- update the event to indicate this error
                event.setError(new service.Bandwagon.RPC.Error(service.Bandwagon.RPC.Constants.BANDWAGON_RPC_SERVICE_ERROR, response.text().toString()));
            }
            else
            {
                // unknown response -- update the event to indicate an error
                event.setError(new service.Bandwagon.RPC.Error(service.Bandwagon.RPC.Constants.BANDWAGON_RPC_SERVICE_ERROR_UNEXPECTED_XML));
            }
        }

        if (callback)
            callback(event);
    }

    this.rpcSend(service.Bandwagon.RPC.Constants.BANDWAGON_RPC_EVENT_TYPE_BANDWAGON_RPC_SHARE_TO_EMAIL_COMPLETE, 
                 internalCallback, 
                 service.Bandwagon.RPC.Constants.BANDWAGON_RPC_EVENT_TYPE_BANDWAGON_RPC_SHARE_TO_EMAIL_ACTION,
                 "POST",
                 data);    
}