var client = require("../client");
var util = require("util");

/*section: monitor
 *comment: create a new monitor
 *params:
 *  type: one of "metric alert" or "service check"
 *  query: the monitor query to use, you probably want to read datadog's [monitor create](http://docs.datadoghq.com/api/#monitor-create) docs
 *  properties: |
 *    optional, an object containing any of the following
 *    * name: the name of the monitor
 *    * message: the message for the monitor
 *    * options: an object, to see available options please see the [monitor create](http://docs.datadoghq.com/api/#monitor-create) docs
 *  callback: function(err, res)
 *example: |
 *  ```javascript
 *  var dogapi = require("dogapi");
 *  var options = {
 *    api_key: "api_key",
 *    app_key: "app_key"
 *  };
 *  dogapi.initialize(options);
 *  var metricType = "metric alert";
 *  var query = "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100";
 *  dogapi.monitor.create(metricType, query, function(err, res){
 *    console.dir(res);
 *  });
 *  ```
 */
function create(type, query, properties, callback){
    if(arguments.length < 4 && typeof arguments[2] === "function"){
        callback = properties;
        properties = {};
    }

    var params = {
        body: {
            type: type,
            query: query
        }
    };

    if(typeof properties === "object"){
        if(properties.name){
            params.body.name = properties.name;
        }
        if(properties.messsage){
            params.body.message = properties.message;
        }
        if(typeof properties.options === "object"){
            params.body.options = properties.options;
        }
    }
    client.request("POST", "/monitor", params, callback);
}

/*section: monitor
 *comment: get an existing monitor's details
 *params:
 *  monitorId: the id of the monitor
 *  groupStates: an array containing any of the following "all", "alert", "warn", or "no data"
 *  callback: function(err, res)
 *example: |
 *  ```javascript
 *  var dogapi = require("dogapi");
 *  var options = {
 *    api_key: "api_key",
 *    app_key: "app_key"
 *  };
 *  dogapi.initialize(options);
 *  dogapi.monitor.get(1234, function(err, res){
 *    console.dir(res);
 *  });
 *  ```
 */
function get(monitorId, groupStates, callback){
    if(arguments.length < 3 && typeof arguments[1] === "function"){
        callback = groupStates;
        groupStates = undefined;
    }

    var params = {};
    if(groupStates){
        params.query = {
            group_states: groupStates.join(",")
        };
    }

    client.request("GET", util.format("/monitor/%s", monitorId), params, callback);
}

/*section: monitor
 *comment: get all monitors
 *params:
 *  options: |
 *    optional, an object containing any of the following
 *    * group_states: an array containing any of the following "all", "alert", "warn", or "no data"
 *    * tags: an array of "tag:value"'s to filter on
 *  callback: function(err, res)
 *example: |
 *  ```javascript
 *  var dogapi = require("dogapi");
 *  var options = {
 *    api_key: "api_key",
 *    app_key: "app_key"
 *  };
 *  dogapi.initialize(options);
 *  dogapi.monitor.getAll(function(err, res){
 *    console.dir(res);
 *  });
 *  ```
 */
function getAll(options, callback){
    if(arguments.length < 2 && typeof arguments[0] === "function"){
        callback = options;
        options = {};
    }
    var params = {};
    if(typeof options === "object"){
        params.query = {};
        if(options.group_states){
            params.query.group_states = options.group_states.join(",");
        }
        if(options.tags){
            params.query.tags = options.tags.join(",");
        }
    }
    client.request("GET", "/monitor", params, callback);
}

/*section: monitor
 *comment: update a monitor's details
 *params:
 *  monitorId: the id of the monitor to edit
 *  query: the query that the monitor should have, see the [monitor create](http://docs.datadoghq.com/api/#monitor-create) docs for more info
 *  properties: |
 *    optional, an object containing any of the following
 *    * name: the name of the monitor
 *    * message: the message for the monitor
 *    * options: an object, to see available options please see the [monitor create](http://docs.datadoghq.com/api/#monitor-create) docs
 *  callback: function(err, res)
 *example: |
 *  ```javascript
 *  var dogapi = require("dogapi");
 *  var options = {
 *    api_key: "api_key",
 *    app_key: "app_key"
 *  };
 *  dogapi.initialize(options);
 *  var query = "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100";
 *  dogapi.monitor.update(1234, query, function(err, res){
 *    console.dir(res);
 *  });
 *  ```
 */
function update(monitorId, query, properties, callback){
    if(arguments.length < 4 && typeof arguments[2] === "function"){
        callback = properties;
        properties = {};
    }

    var params = {
        body: {
            query: query
        }
    };

    if(typeof properties === "object"){
        if(properties.name){
            params.body.name = properties.name;
        }
        if(properties.messsage){
            params.body.message = properties.message;
        }
        if(typeof properties.options === "object"){
            params.body.options = properties.options;
        }
    }
    client.request("PUT", util.format("/monitor/%s", monitorId), params, callback);
}

/*section: monitor
 *comment: delete an existing monitor
 *params:
 *  monitorId: the id of the monitor to remove
 *  callback: function(err, res)
 *example: |
 *  ```javascript
 *  var dogapi = require("dogapi");
 *  var options = {
 *    api_key: "api_key",
 *    app_key: "app_key"
 *  };
 *  dogapi.initialize(options);
 *  dogapi.monitor.remove(1234, function(err, res){
 *    console.dir(res);
 *  });
 *  ```
 */
function remove(monitorId, callback){
    client.request("DELETE", util.format("/monitor/%s", monitorId), callback);
}

/*section: monitor
 *comment: mute an existing monitor
 *params:
 *  monitorId: the id of the monitor to mute
 *  options: |
 *    optional, an object containing any of the following
 *    * scope: the scope to mute (e.g. "role:db")
 *    * end: POSIX timestamp indicating when the mute should end
 *  callback: function(err, res)
 *example: |
 *  ```javascript
 *  var dogapi = require("dogapi");
 *  var options = {
 *    api_key: "api_key",
 *    app_key: "app_key"
 *  };
 *  dogapi.initialize(options);
 *  dogapi.monitor.mute(1234, function(err, res){
 *    console.dir(res);
 *  });
 *  ```
 */
function mute(monitorId, options, callback){
    if(arguments.length < 3 && typeof arguments[1] === "function"){
        callback = options;
        options = {};
    }
    var params = {};
    if(typeof options === "object"){
        params.body = {};
        if(options.scope){
            params.body.scope = options.scope;
        }
        if(options.end){
            params.body.end = parseInt(options.end);
        }
    }
    client.request("POST", util.format("/monitor/%s/mute"), params, callback);
}

/*section: monitor
 *comment: mute all monitors
 *params:
 *  callback: function(err, res)
 *example: |
 *  ```javascript
 *  var dogapi = require("dogapi");
 *  var options = {
 *    api_key: "api_key",
 *    app_key: "app_key"
 *  };
 *  dogapi.initialize(options);
 *  dogapi.monitor.muteAll(function(err, res){
 *    console.dir(res);
 *  });
 *  ```
 */
function muteAll(callback){
    client.request("POST", "/monitor/mute_all", callback);
}

/*section: monitor
 *comment: unmute an existing monitor
 *params:
 *  monitorId: the id of the monitor to unmute
 *  scope: optional, a scope to apply the unmute to (e.g. "role:db")
 *  callback: function(err, res)
 *example: |
 *  ```javascript
 *  var dogapi = require("dogapi");
 *  var options = {
 *    api_key: "api_key",
 *    app_key: "app_key"
 *  };
 *  dogapi.initialize(options);
 *  dogapi.monitor.unmute(1234, function(err, res){
 *    console.dir(res);
 *  });
 *  ```
 */
function unmute(monitorId, scope, callback){
    if(arguments.length < 3 && typeof arguments[1] === "function"){
        callback = scope;
        scope = undefined;
    }
    var params = {};
    if(scope){
        params.body = {
            scope: scope
        };
    }
    client.request("POST", util.format("/monitor/%s/unmute", monitorId), params, callback);
}

/*section: monitor
 *comment: unmute all monitors
 *params:
 *  callback: function(err, res)
 *example: |
 *  ```javascript
 *  var dogapi = require("dogapi");
 *  var options = {
 *    api_key: "api_key",
 *    app_key: "app_key"
 *  };
 *  dogapi.initialize(options);
 *  dogapi.monitor.unmuteAll(function(err, res){
 *    console.dir(res);
 *  });
 *  ```
 */
function unmuteAll(callback){
    client.request("POST", "/monitor/unmute_all", callback);
}

module.exports = {
    create: create,
    get: get,
    update: update,
    remove: remove,
    getAll: getAll,
    mute: mute,
    muteAll: muteAll,
    unmute: unmute,
    unmuteAll: unmuteAll,
    getUsage: function(){
        return [
            "${command} monitor create <type> <query> [--name <name>] [--message <message>]",
            "${command} monitor get <monitor-id> [--states <states>]",
            "${command} monitor getall [--states <states>] [--tags <tags>]",
            "${command} monitor mute <monitor-id> [--scope <scope>] [--end <end>]",
            "${command} monitor muteall",
            "${command} monitor remove <monitor-id>",
            "${command} monitor unmute <monitor-id> [--scope <scope>]",
            "${command} monitor unmuteall",
            "${command} monitor update <monitor-id> <query> [--name <name>] [--message <message>]"
        ];
    },
    getHelp: function(){
        return [
            "Monitor:",
            "  Subcommands:",
            "    create <type> <query>          create a new monitor",
            "    get <monitor-id>               get a monitors details",
            "    getall                         get a list of all monitors",
            "    mute <monitor-id>              mute the monitor with the id <monitor-id>",
            "    muteall                        mute all monitors",
            "    remove <monitor-id>            delete the monitor with the id <monitor-id>",
            "    unmute <monitor-id>            unmute the monitor with the id <monitor-id>",
            "    unmuteall                      unmute all monitors",
            "    update <monitor-id> <query>    update an existing monitor",
            "",
            "  Options:",
            "    --states <states>              a comma separated list containing any of \"all\", \"alert\", \"warn\", or \"no data\"",
            "    --tags <tags>                  a comma separated list of \"tag:value\"'s",
            "    --scope <scope>                the scope of the monitor to mute (e.g. \"role:db\")",
            "    --end <end>                    POSIX timestamp for when the mute should end",
            "    --name <name>                  the name for the monitor",
            "    --message <message>            the message for the monitor"
        ];
    },
    handleCli: function(subcommand, args, callback){
        var states = [];
        if(args["states"]){
            states = args["states"].split(",");
        }

        var tags = [];
        if(args["tags"]){
            tags = args["tags"].split(",");
        }

        var name = args["name"];
        var message = args["message"];

        if(subcommand === "get"){
            var monitorId = args._[4];
            get(monitorId, states, callback);
        } else if(subcommand === "getall"){
            var options = {};
            if(states.length){
                options.group_states = states;
            }
            if(tags.length){
                options.tags = tags;
            }
            getAll(options, callback);
        } else if(subcommand === "mute"){
            var monitorId = args._[4];
            var options = {};
            if(args["scope"]){
                options.scope = args["scope"];
            }
            if(args["end"]){
                options.end = args["end"];
            }
            mute(monitorId, options, callback);
        } else if(subcommand === "unmute"){
            var monitorId = args._[4];
            var scope = args["scope"];
            unmute(monitorId, scope, callback);
        } else if(subcommand === "unmuteall"){
            unmuteAll(callback);
        } else if(subcommand === "muteall"){
            muteAll(callback);
        } else if(subcommand === "remove"){
            var monitorId = args._[4];
            remove(monitorId, callback);
        } else if(subcommand === "create" && args._.length > 5){
            var type = args._[4];
            var query = args._[5];
            var properties = {};
            if(name){
                properties.name = name;
            }
            if(message){
                properties.message = message;
            }
            create(type, query, properties, callback);
        } else if(subcommand === "update" && args._.length > 5){
            var monitorId = args._[4];
            var query = args._[5];
            var properties = {};
            if(name){
                properties.name = name;
            }
            if(message){
                properties.message = message;
            }
            update(monitorId, query, properties, callback);
        } else {
            callback("unknown subcommand or arguments try `dogapi monitor --help` for help", false);
        }
    }
};