const util = require('util');

module.exports = function(client) {
  /* section: event
     *comment: |
     *  create a new event
     *params:
     *  title: the title of the event
     *  text: the body of the event
     *  properties: |
     *    an optional object continaing any of the following additional optional properties
     *    * date_happened: POSIX timestamp of when it happened
     *    * priority: "normal" or "low" [defualt: "normal"]
     *    * host: the host name to associate with the event
     *    * tags: array of "tag:value"'s to associate with the event
     *    * alert_type: "error", "warning", "info" or "success" [defualt: "info"]
     *    * aggregation_key: an arbitrary string used to aggregate like events
     *    * source_type_name: options: "nagios", "hudson", "jenkins", "user", "my apps", "feed", "chef", "puppet", "git", "bitbucket", "fabric", "capistrano"
     *  callback: |
     *    function(err, res)
     *example: |
     *  ```javascript
     *   const dogapi = require("dogapi");
     *   const options = {
     *     api_key: "api_key",
     *     app_key: "app_key"
     *   };
     *   dogapi.initialize(options);
     *   const title = "some new event";
     *   const text = "IT HAPPENED!";
     *   dogapi.event.create(title, text, function(err, res){
     *     console.dir(res);
     *   });
     *   title = "another event";
     *   text = "IT HAPPENED AGAIN!";
     *   const properties = {
     *     tags: ["some:tag"],
     *     alert_type: "error"
     *   };
     *   dogapi.event.create(title, text, properties, function(err, res){
     *     console.dir(res);
     *   });
     *  ```
     */
  function create(title, text, properties, callback) {
    if (arguments.length < 4 && typeof arguments[2] === 'function') {
      callback = properties;
      properties = {};
    }
    if (typeof properties !== 'object') {
      properties = {};
    }

    properties.title = title;
    properties.text = text;

    const params = {
      body: properties
    };
    client.request('POST', '/events', params, callback);
  }

  /* section: event
     *comment: |
     *  get event details from the provided event id
     *params:
     *  eventId: |
     *    the id of the event to fetch
     *  callback: |
     *    function(err, res)
     *example: |
     *  ```javascript
     *   const dogapi = require("dogapi");
     *   const options = {
     *     api_key: "api_key",
     *     app_key: "app_key"
     *   };
     *   dogapi.initialize(options);
     *   dogapi.event.get(10005, function(err, res){
     *     console.dir(res);
     *   });
     *  ```
     */
  function get(eventId, callback) {
    client.request('GET', util.format('/events/%s', eventId), callback);
  }

  /* section: event
     *comment: |
     *  query the event stream
     *params:
     *  start: POSIX timestamp for start of query
     *  end: POSIX timestamp for end of query
     *  parameters: |
     *    optional parameters to use for the query
     *    * priority: "low" or "normal"
     *    * sources: comma separated list of sources (e.g. "jenkins,user")
     *    * tags: comma separated list of tags (e.g. "tag:value1,tag:value2")
     *  callback: |
     *    function(err, res)
     *example: |
     *  ```javascript
     *   const dogapi = require("dogapi");
     *   const options = {
     *     api_key: "api_key",
     *     app_key: "app_key"
     *   };
     *   dogapi.initialize(options);
     *   const now = parseInt(new Date().getTime() / 1000);
     *   const then = now - 3600; // an hour ago
     *   const parameters = {
     *     tags: "some:tag",
     *     sources: "jenkins"
     *   };
     *   dogapi.event.query(then, now, parameters, function(err, res){
     *     console.dir(res);
     *   });
     *  ```
     */
  function query(start, end, parameters, callback) {
    if (arguments.length < 4 && typeof arguments[2] === 'function') {
      callback = parameters;
      parameters = {};
    }

    if (typeof parameters !== 'object') {
      parameters = {};
    }
    parameters.start = start;
    parameters.end = end;

    const params = {
      query: parameters
    };

    client.request('GET', '/events', params, callback);
  }

  return {
    create,
    get,
    query,
    getUsage() {
      return [
        '  dogapi event get <event-id>',
        '  dogapi event query <from> <to> [--priority <priority>] [--sources <sources>] [--tags <tags>]',
        '  dogapi event create <title> <text> [--time <timestamp>] [--priority <priority>] [--host <host>] [--tags <tags>] [--type <type>] [--agg-key <agg-key>] [--source <source>]'
      ];
    },
    getHelp() {
      return [
        'Event:',
        '  Subcommands:',
        '    get <event-id>           get the event with the provided <event-id>',
        '    query <from> <to>        query the event stream between <from> and <to> POSIX timestamps',
        '    create <title> <text>    create a new event with <title> and <text>',
        '  Options:',
        '    --priority <priority>    the priority of the event "normal" or "low"',
        '    --sources <sources>      a comma separated list of sources (e.g. "users,jenkins,chef")',
        '    --tags <tags>            a comma separated list of "tag:value"\'s',
        '    --time <time>            a POSIX timestamp for when the event happened',
        '    --host <host>            the host to associate the event to',
        '    --type <type>            the event type "error", "warning", "info" or "success"',
        '    --agg-key <agg-key>      an aggregation key to use to associate like events',
        '    --source <source>        the source to associate with this event (e.g. "users", "jenkins", etc)'
      ];
    },
    handleCli(subcommand, args, callback) {
      if (subcommand === 'get' && args._.length > 4) {
        get(parseInt(args._[4]), callback);
      } else if (subcommand === 'query' && args._.length > 5) {
        const from = parseInt(args._[4]);
        const to = parseInt(args._[5]);
        const parameters = {};
        if (args.sources) {
          parameters.sources = args.sources;
        }
        if (args.tags) {
          parameters.tags = args.tags;
        }
        query(from, to, parameters, callback);
      } else if (subcommand === 'create' && args._.length > 5) {
        const title = args._[4];
        const text = args._[5];
        const properties = {};
        if (args.priority) {
          properties.priority = args.priority;
        }
        if (args.host) {
          properties.host = args.host;
        }
        if (args.time) {
          properties.date_happened = parseInt(args.time);
        }
        if (args.tags) {
          properties.tags = args.tags.split(',');
        }
        if (args['agg-key']) {
          properties.aggregation_key = args['agg-key'];
        }
        if (args.source) {
          properties.source_type_name = args.source;
        }
        create(title, text, properties, callback);
      } else {
        return callback(
          'unknown subcommand or arguments try `dogapi event --help` for help',
          false
        );
      }
    }
  };
};