var roclient = (function () {



    var roc = {};



    roc.ArgumentMap = Backbone.Model.extend({







    }),



    // matches a action invoke resource 19.0 representation 

    roc.Invoke = Backbone.Model.extend({



        getResult: function () {

            var result = this.get("result");

            var resultType = this.get("resultType");



            if (resultType === "scalar") {

                return result.value;

            }

            if (resultType === "object") {

                return new roc.DomainObject(result);

            }

            if (resultType === "list") {

                if (result) {

                    return new roc.LinkList(result.value);

                }

                return null;

            }

            if (resultType === "void") {

                return null;

            }



            return null;

        },



        fetch: function (attributes, options) {

            if (this.method === "GET") {

                var map = JSON.stringify(this.toJSON());

                var encodedMap = encodeURI(map);



                this.url = this.url + "?" + encodedMap;



                Backbone.Model.prototype.fetch.call(this, attributes, options);

            }

            else if (this.method === "POST") {



                options = options || {};

                var parent = this;

                options.error = function (originalModel, resp, iOptions) {

                    var rs = $.parseJSON(resp.responseText);

                    //parent.set(rs);

                    parent.trigger("requestFailed", { statusCode: resp.status, model: new roc.Invoke(rs) });

                };



                Backbone.Model.prototype.save.call(this, attributes, options);

            }

            else if (this.method === "PUT") {

                // set id so not new ? 

                Backbone.Model.prototype.save.call(this, attributes, options);

            }

        }



    });





    // matches an action representation 18.0 

    roc.ObjectAction = Backbone.Model.extend({

        getLinks: function () {

            return new roc.LinkList(this.get("links"));

        },



        getActionResult: function () {

            var links = this.getLinks();

            var resultsLink = _.find(links.models, function (i) {

                return i.targetType() === "urn:org.restfulobjects:repr-types/action-result";

            });

            return resultsLink.getTarget();

        },



        getHasArguments: function () {

            return this.get("extensions").hasParams;

        }



    });





    // matches a domain object representation 14.0 

    roc.DomainObject = Backbone.Model.extend({

        url: function () {



            if (!this.selfUrl) {



                var links = this.get("links");

                var selfLink = _.find(links, function (i) {

                    return i.rel === "self";

                });



                this.selfUrl = selfLink.href;

            }



            return this.selfUrl;

        },



        updateUrl: function () {

            var links = this.get("links");

            var updateLink = _.find(links, function (i) {

                return i.rel === "urn:org.restfulobjects:rels/update";

            });



            return updateLink.href;

        },



        getMemberLinks: function (id) {

            return new roc.LinkList(this.get("members")[id].links);

        },



        getObjectAction: function (id) {

            var links = this.getMemberLinks(id);

            var detailsLink = _.find(links.models, function (i) {

                return i.targetType() === "urn:org.restfulobjects:repr-types/object-action";

            });

            return detailsLink.getTarget();

        },



        getObjectActions: function () {

            var actions = [];



            for (id in this.get("members")) {



                var links = this.getMemberLinks(id);

                var detailsLink = _.find(links.models, function (i) {

                    return i.targetType() === "urn:org.restfulobjects:repr-types/object-action";

                });



                actions.push(detailsLink.getTarget());

            }



            return actions;

        },





        getArgumentMap: function () {

            var map = new roc.ArgumentMap();

            map.url = this.updateUrl();

            map.id = this.get("instanceId");

            return map;

        },



        setEditMode: function (flag) {

            this.set("editMode", flag);

        },



        setToArgumentMap: function () {

            for (member in this.get("members")) {

                this.map.set(member, { "value": this.get("members")[member].value });

            }



            var parent = this;



            this.map.on("change", function () {

                parent.setFromArgumentMap();

            });



        },



        setFromArgumentMap: function () {

            this.set(this.map.attributes);

        },



        save: function (attributes, options) {

            this.map = this.getArgumentMap();

            this.setToArgumentMap();

            this.map.save(attributes, options);

        }



    });





    // matches the Link representation 2.7

    roc.Link = Backbone.Model.extend({



        // the url that this link points to 

        targetUrl: function () {

            var href = this.get("href");

            return href;

        },



        // the media type that this link points to 

        targetType: function () {

            var type = this.get("type");

            var parms = type.split(";");



            for (var i = 0; i < parms.length; i++) {

                if ($.trim(parms[i]).substring(0, 7) === "profile") {

                    return parms[i].split("=")[1].replace(/\"/g, '');

                }

            }



            return "";

        },



        // the http method needed on the link

        method: function () {

            return this.get("method");

        },



        // get the object that this link points to 

        getTarget: function () {

            var matchingType = RepTypeToModel[this.targetType()];

            var target = new matchingType();

            target.url = this.targetUrl();

            target.method = this.method();

            return target;

        }



    });



    // matches a list representation 11.0 

    roc.LinkList = Backbone.Collection.extend({

        model: roc.Link,



        parse: function (response) {

            return response.value;

        }

    });



    // matches the home page representation  5.0 

    roc.Home = Backbone.Model.extend({

        url: appPath,



        serviceLinksUrl: function () {

            var links = this.get("links");

            var services = _.find(links, function (o) { return o.rel.indexOf("urn:org.restfulobjects:rels/services") != -1; });

            return services.href;

        },



        getServiceLinks: function () {

            var services = new roc.LinkList();

            services.url = this.serviceLinksUrl();

            return services;

        }

    });





    // map of representation types to models



    var RepTypeToModel = {

        "urn:org.restfulobjects:repr-types/homepage": roc.Home,

        "urn:org.restfulobjects:repr-types/object": roc.DomainObject,

        "urn:org.restfulobjects:repr-types/object-action": roc.ObjectAction,

        "urn:org.restfulobjects:repr-types/action-result": roc.Invoke

    };



    return roc;

} ());