#
# Copyright 2013 Red Hat, Inc
# Copyright Ericsson AB 2014. All rights reserved
#
# Authors: Angus Salkeld <asalkeld@redhat.com>
#          Balazs Gibizer <balazs.gibizer@ericsson.com>
#          Ildiko Vancsa <ildiko.vancsa@ericsson.com>
#
#    Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

import argparse
import functools
import json

from oslo_serialization import jsonutils
from oslo_utils import strutils
import six
from six import moves

from ceilometerclient.common import utils
from ceilometerclient import exc
from ceilometerclient.v2 import options


ALARM_STATES = ['ok', 'alarm', 'insufficient data']
ALARM_SEVERITY = ['low', 'moderate', 'critical']
ALARM_OPERATORS = ['lt', 'le', 'eq', 'ne', 'ge', 'gt']
ALARM_COMBINATION_OPERATORS = ['and', 'or']
STATISTICS = ['max', 'min', 'avg', 'sum', 'count']
GNOCCHI_AGGREGATION = ['last', 'min', 'median', 'sum',
                       'std', 'first', 'mean', 'count',
                       'moving-average', 'max']
GNOCCHI_AGGREGATION.extend(['%spct' % num for num in moves.xrange(1, 100)])

AGGREGATES = {'avg': 'Avg',
              'count': 'Count',
              'max': 'Max',
              'min': 'Min',
              'sum': 'Sum',
              'stddev': 'Standard deviation',
              'cardinality': 'Cardinality'}
OPERATORS_STRING = dict(gt='>', ge='>=',
                        lt='<', le="<=",
                        eq='==', ne='!=')
ORDER_DIRECTIONS = ['asc', 'desc']
COMPLEX_OPERATORS = ['and', 'or']
SIMPLE_OPERATORS = ["=", "!=", "<", "<=", '>', '>=']

DEFAULT_API_LIMIT = ('API server limits result to <default_api_return_limit> '
                     'rows if no limit provided. Option is configured in '
                     'ceilometer.conf [api] group')


class NotEmptyAction(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        values = values or getattr(namespace, self.dest)
        if not values or values.isspace():
            raise exc.CommandError('%s should not be empty' % self.dest)
        setattr(namespace, self.dest, values)


def obsoleted_by(new_dest):
    class ObsoletedByAction(argparse.Action):
        def __call__(self, parser, namespace, values, option_string=None):
            old_dest = option_string or self.dest
            print('%s is obsolete! See help for more details.' % old_dest)
            setattr(namespace, new_dest, values)
    return ObsoletedByAction


@utils.arg('-q', '--query', metavar='<QUERY>',
           help='key[op]data_type::value; list. data_type is optional, '
                'but if supplied must be string, integer, float, or boolean.')
@utils.arg('-m', '--meter', metavar='<NAME>', required=True,
           action=NotEmptyAction, help='Name of meter to list statistics for.')
@utils.arg('-p', '--period', metavar='<PERIOD>',
           help='Period in seconds over which to group samples.')
@utils.arg('-g', '--groupby', metavar='<FIELD>', action='append',
           help='Field for group by.')
@utils.arg('-a', '--aggregate', metavar='<FUNC>[<-<PARAM>]', action='append',
           default=[], help=('Function for data aggregation. '
                             'Available aggregates are: '
                             '%s.' % ", ".join(AGGREGATES.keys())))
def do_statistics(cc, args):
    """List the statistics for a meter."""
    aggregates = []
    for a in args.aggregate:
        aggregates.append(dict(zip(('func', 'param'), a.split("<-"))))
    api_args = {'meter_name': args.meter,
                'q': options.cli_to_array(args.query),
                'period': args.period,
                'groupby': args.groupby,
                'aggregates': aggregates}
    try:
        statistics = cc.statistics.list(**api_args)
    except exc.HTTPNotFound:
        raise exc.CommandError('Samples not found: %s' % args.meter)
    else:
        fields_display = {'duration': 'Duration',
                          'duration_end': 'Duration End',
                          'duration_start': 'Duration Start',
                          'period': 'Period',
                          'period_end': 'Period End',
                          'period_start': 'Period Start',
                          'groupby': 'Group By'}
        fields_display.update(AGGREGATES)
        fields = ['period', 'period_start', 'period_end']
        if args.groupby:
            fields.append('groupby')
        if args.aggregate:
            for a in aggregates:
                if 'param' in a:
                    fields.append("%(func)s/%(param)s" % a)
                else:
                    fields.append(a['func'])
            for stat in statistics:
                stat.__dict__.update(stat.aggregate)
        else:
            fields.extend(['max', 'min', 'avg', 'sum', 'count'])
        fields.extend(['duration', 'duration_start', 'duration_end'])
        cols = [fields_display.get(f, f) for f in fields]
        utils.print_list(statistics, fields, cols)


@utils.arg('-q', '--query', metavar='<QUERY>',
           help='key[op]data_type::value; list. data_type is optional, '
                'but if supplied must be string, integer, float, or boolean.')
@utils.arg('-m', '--meter', metavar='<NAME>',
           action=NotEmptyAction, help='Name of meter to show samples for.')
@utils.arg('-l', '--limit', metavar='<NUMBER>',
           help='Maximum number of samples to return. %s' % DEFAULT_API_LIMIT)
def do_sample_list(cc, args):
    """List the samples (return OldSample objects if -m/--meter is set)."""
    if not args.meter:
        return _do_sample_list(cc, args)
    else:
        return _do_old_sample_list(cc, args)


def _do_old_sample_list(cc, args):
    fields = {'meter_name': args.meter,
              'q': options.cli_to_array(args.query),
              'limit': args.limit}
    try:
        samples = cc.samples.list(**fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Samples not found: %s' % args.meter)
    else:
        field_labels = ['Resource ID', 'Name', 'Type', 'Volume', 'Unit',
                        'Timestamp']
        fields = ['resource_id', 'counter_name', 'counter_type',
                  'counter_volume', 'counter_unit', 'timestamp']
        utils.print_list(samples, fields, field_labels, sortby=None)


def _do_sample_list(cc, args):
    fields = {
        'q': options.cli_to_array(args.query),
        'limit': args.limit
    }
    samples = cc.new_samples.list(**fields)
    field_labels = ['ID', 'Resource ID', 'Name', 'Type', 'Volume', 'Unit',
                    'Timestamp']
    fields = ['id', 'resource_id', 'meter', 'type', 'volume', 'unit',
              'timestamp']
    utils.print_list(samples, fields, field_labels, sortby=None)


@utils.arg('sample_id', metavar='<SAMPLE_ID>', action=NotEmptyAction,
           help='ID (aka message ID) of the sample to show.')
def do_sample_show(cc, args):
    '''Show a sample.'''
    try:
        sample = cc.new_samples.get(args.sample_id)
    except exc.HTTPNotFound:
        raise exc.CommandError('Sample not found: %s' % args.sample_id)

    fields = ['id', 'meter', 'volume', 'type', 'unit', 'source',
              'resource_id', 'user_id', 'project_id',
              'timestamp', 'recorded_at', 'metadata']
    data = dict((f, getattr(sample, f, '')) for f in fields)
    utils.print_dict(data, wrap=72)


def _restore_shadowed_arg(shadowed, observed):
    def wrapper(func):
        @functools.wraps(func)
        def wrapped(cc, args):
            v = getattr(args, observed, None)
            setattr(args, shadowed, v)
            return func(cc, args)
        return wrapped
    return wrapper


@utils.arg('--project-id', metavar='<SAMPLE_PROJECT_ID>',
           dest='sample_project_id',
           help='Tenant to associate with sample '
                '(configurable by admin users only).')
@utils.arg('--user-id', metavar='<SAMPLE_USER_ID>',
           dest='sample_user_id',
           help='User to associate with sample '
                '(configurable by admin users only).')
@utils.arg('-r', '--resource-id', metavar='<RESOURCE_ID>', required=True,
           help='ID of the resource.')
@utils.arg('-m', '--meter-name', metavar='<METER_NAME>', required=True,
           action=NotEmptyAction, help='The meter name.')
@utils.arg('--meter-type', metavar='<METER_TYPE>', required=True,
           help='The meter type.')
@utils.arg('--meter-unit', metavar='<METER_UNIT>', required=True,
           help='The meter unit.')
@utils.arg('--sample-volume', metavar='<SAMPLE_VOLUME>', required=True,
           help='The sample volume.')
@utils.arg('--resource-metadata', metavar='<RESOURCE_METADATA>',
           help='Resource metadata. Provided value should be a set of '
                'key-value pairs e.g. {"key":"value"}.')
@utils.arg('--timestamp', metavar='<TIMESTAMP>',
           help='The sample timestamp.')
@utils.arg('--direct', metavar='<DIRECT>', default=False,
           help='Post sample to storage directly.')
@_restore_shadowed_arg('project_id', 'sample_project_id')
@_restore_shadowed_arg('user_id', 'sample_user_id')
def do_sample_create(cc, args={}):
    """Create a sample."""
    arg_to_field_mapping = {
        'meter_name': 'counter_name',
        'meter_unit': 'counter_unit',
        'meter_type': 'counter_type',
        'sample_volume': 'counter_volume',
    }
    fields = {}
    for var in vars(args).items():
        k, v = var[0], var[1]
        if v is not None:
            if k == 'resource_metadata':
                try:
                    fields[k] = json.loads(v)
                except ValueError:
                    msg = ('Invalid resource metadata, it should be a json'
                           ' string, like: \'{"foo":"bar"}\'')
                    raise exc.CommandError(msg)
            else:
                fields[arg_to_field_mapping.get(k, k)] = v
    sample = cc.samples.create(**fields)
    fields = ['counter_name', 'user_id', 'resource_id',
              'timestamp', 'message_id', 'source', 'counter_unit',
              'counter_volume', 'project_id', 'resource_metadata',
              'counter_type']
    data = dict([(f.replace('counter_', ''), getattr(sample[0], f, ''))
                 for f in fields])
    utils.print_dict(data, wrap=72)


@utils.arg('-q', '--query', metavar='<QUERY>',
           help='key[op]data_type::value; list. data_type is optional, '
                'but if supplied must be string, integer, float, or boolean.')
@utils.arg('-l', '--limit', metavar='<NUMBER>',
           help='Maximum number of meters to return. %s' % DEFAULT_API_LIMIT)
def do_meter_list(cc, args={}):
    """List the user's meters."""
    meters = cc.meters.list(q=options.cli_to_array(args.query),
                            limit=args.limit)
    field_labels = ['Name', 'Type', 'Unit', 'Resource ID', 'User ID',
                    'Project ID']
    fields = ['name', 'type', 'unit', 'resource_id', 'user_id',
              'project_id']
    utils.print_list(meters, fields, field_labels,
                     sortby=0)


@utils.arg('samples_list', metavar='<SAMPLES_LIST>', action=NotEmptyAction,
           help='Json array with samples to create.')
@utils.arg('--direct', metavar='<DIRECT>', default=False,
           help='Post samples to storage directly.')
def do_sample_create_list(cc, args={}):
    """Create a sample list."""
    sample_list_array = json.loads(args.samples_list)
    samples = cc.samples.create_list(sample_list_array, direct=args.direct)
    field_labels = ['Resource ID', 'Name', 'Type', 'Volume', 'Unit',
                    'Timestamp']
    fields = ['resource_id', 'counter_name', 'counter_type',
              'counter_volume', 'counter_unit', 'timestamp']
    utils.print_list(samples, fields, field_labels, sortby=None)


def _display_alarm_list(alarms, sortby=None):
    # omit action initially to keep output width sane
    # (can switch over to vertical formatting when available from CLIFF)
    field_labels = ['Alarm ID', 'Name', 'State', 'Severity', 'Enabled',
                    'Continuous', 'Alarm condition', 'Time constraints']
    fields = ['alarm_id', 'name', 'state', 'severity', 'enabled',
              'repeat_actions', 'rule', 'time_constraints']
    utils.print_list(
        alarms, fields, field_labels,
        formatters={'rule': alarm_rule_formatter,
                    'time_constraints': time_constraints_formatter_brief},
        sortby=sortby)


def _display_rule(type, rule):
    if type == 'threshold':
        return ('%(statistic)s(%(meter_name)s) %(comparison_operator)s '
                '%(threshold)s during %(evaluation_periods)s x %(period)ss' %
                {
                    'meter_name': rule['meter_name'],
                    'threshold': rule['threshold'],
                    'statistic': rule['statistic'],
                    'evaluation_periods': rule['evaluation_periods'],
                    'period': rule['period'],
                    'comparison_operator': OPERATORS_STRING.get(
                        rule['comparison_operator'])
                })
    elif type == 'combination':
        return ('combinated states (%(operator)s) of %(alarms)s' % {
            'operator': rule['operator'].upper(),
            'alarms': ", ".join(rule['alarm_ids'])})
    else:
        # just dump all
        return "\n".join(["%s: %s" % (f, v)
                          for f, v in six.iteritems(rule)])


def alarm_rule_formatter(alarm):
    return _display_rule(alarm.type, alarm.rule)


def _display_time_constraints_brief(time_constraints):
    if time_constraints:
        return ', '.join('%(name)s at %(start)s %(timezone)s for %(duration)ss'
                         % {
                             'name': tc['name'],
                             'start': tc['start'],
                             'duration': tc['duration'],
                             'timezone': tc.get('timezone', '')
                         }
                         for tc in time_constraints)
    else:
        return 'None'


def time_constraints_formatter_brief(alarm):
    return _display_time_constraints_brief(getattr(alarm,
                                                   'time_constraints',
                                                   None))


def _infer_type(detail):
    if 'type' in detail:
        return detail['type']
    elif 'meter_name' in detail['rule']:
        return 'threshold'
    elif 'alarms' in detail['rule']:
        return 'combination'
    else:
        return 'unknown'


def alarm_change_detail_formatter(change):
    detail = json.loads(change.detail)
    fields = []
    if change.type == 'state transition':
        fields.append('state: %s' % detail['state'])
    elif change.type == 'creation' or change.type == 'deletion':
        for k in ['name', 'description', 'type', 'rule', 'severity']:
            if k == 'rule':
                fields.append('rule: %s' % _display_rule(detail['type'],
                                                         detail[k]))
            else:
                fields.append('%s: %s' % (k, detail[k]))
        if 'time_constraints' in detail:
            fields.append('time_constraints: %s' %
                          _display_time_constraints_brief(
                              detail['time_constraints']))
    elif change.type == 'rule change':
        for k, v in six.iteritems(detail):
            if k == 'rule':
                fields.append('rule: %s' % _display_rule(_infer_type(detail),
                                                         v))
            else:
                fields.append('%s: %s' % (k, v))
    return '\n'.join(fields)


@utils.arg('-q', '--query', metavar='<QUERY>',
           help='key[op]data_type::value; list. data_type is optional, '
                'but if supplied must be string, integer, float, or boolean.')
def do_alarm_list(cc, args={}):
    """List the user's alarms."""
    alarms = cc.alarms.list(q=options.cli_to_array(args.query))
    _display_alarm_list(alarms, sortby=0)


def alarm_query_formater(alarm):
    qs = []
    for q in alarm.rule['query']:
        qs.append('%s %s %s' % (
            q['field'], OPERATORS_STRING.get(q['op']), q['value']))
    return r' AND\n'.join(qs)


def time_constraints_formatter_full(alarm):
    time_constraints = []
    for tc in alarm.time_constraints:
        lines = []
        for k in ['name', 'description', 'start', 'duration', 'timezone']:
            if k in tc and tc[k]:
                lines.append(r'%s: %s' % (k, tc[k]))
        time_constraints.append('{' + r',\n  '.join(lines) + '}')
    return '[' + r',\n '.join(time_constraints) + ']'


def _display_alarm(alarm):
    fields = ['name', 'description', 'type',
              'state', 'severity', 'enabled', 'alarm_id', 'user_id',
              'project_id', 'alarm_actions', 'ok_actions',
              'insufficient_data_actions', 'repeat_actions']
    data = dict([(f, getattr(alarm, f, '')) for f in fields])
    data.update(alarm.rule)
    if alarm.type == 'threshold':
        data['query'] = alarm_query_formater(alarm)
    if alarm.time_constraints:
        data['time_constraints'] = time_constraints_formatter_full(alarm)
    utils.print_dict(data, wrap=72)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm to show.')
def do_alarm_show(cc, args={}):
    """Show an alarm."""
    alarm = cc.alarms.get(args.alarm_id)
    # alarm.get actually catches the HTTPNotFound exception and turns the
    # result into None if the alarm wasn't found.
    if alarm is None:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    else:
        _display_alarm(alarm)


def common_alarm_arguments(create=False):
    def _wrapper(func):
        @utils.arg('--name', metavar='<NAME>', required=create,
                   help='Name of the alarm (must be unique per tenant).')
        @utils.arg('--project-id', metavar='<ALARM_PROJECT_ID>',
                   dest='alarm_project_id',
                   help='Tenant to associate with alarm '
                   '(configurable by admin users only).')
        @utils.arg('--user-id', metavar='<ALARM_USER_ID>',
                   dest='alarm_user_id',
                   help='User to associate with alarm '
                   '(configurable by admin users only).')
        @utils.arg('--description', metavar='<DESCRIPTION>',
                   help='Free text description of the alarm.')
        @utils.arg('--state', metavar='<STATE>',
                   help='State of the alarm, one of: ' + str(ALARM_STATES))
        @utils.arg('--severity', metavar='<SEVERITY>',
                   help='Severity of the alarm, one of: '
                        + str(ALARM_SEVERITY))
        @utils.arg('--enabled',
                   type=lambda v: strutils.bool_from_string(v, True),
                   metavar='{True|False}',
                   help='True if alarm evaluation/actioning is enabled.')
        @utils.arg('--alarm-action', dest='alarm_actions',
                   metavar='<Webhook URL>', action='append', default=None,
                   help=('URL to invoke when state transitions to alarm. '
                         'May be used multiple times.'))
        @utils.arg('--ok-action', dest='ok_actions',
                   metavar='<Webhook URL>', action='append', default=None,
                   help=('URL to invoke when state transitions to OK. '
                         'May be used multiple times.'))
        @utils.arg('--insufficient-data-action',
                   dest='insufficient_data_actions',
                   metavar='<Webhook URL>', action='append', default=None,
                   help=('URL to invoke when state transitions to '
                         'insufficient data. May be used multiple times.'))
        @utils.arg('--time-constraint', dest='time_constraints',
                   metavar='<Time Constraint>', action='append',
                   default=None,
                   help=('Only evaluate the alarm if the time at evaluation '
                         'is within this time constraint. Start point(s) of '
                         'the constraint are specified with a cron expression'
                         ', whereas its duration is given in seconds. '
                         'Can be specified multiple times for multiple '
                         'time constraints, format is: '
                         'name=<CONSTRAINT_NAME>;start=<CRON>;'
                         'duration=<SECONDS>;[description=<DESCRIPTION>;'
                         '[timezone=<IANA Timezone>]]'))
        @utils.arg('--repeat-actions', dest='repeat_actions',
                   metavar='{True|False}', type=strutils.bool_from_string,
                   default=False,
                   help=('True if actions should be repeatedly notified '
                         'while alarm remains in target state.'))
        @functools.wraps(func)
        def _wrapped(*args, **kwargs):
            return func(*args, **kwargs)
        return _wrapped
    return _wrapper


def common_alarm_gnocchi_arguments(rule_namespace, create=False):
    def _wrapper(func):
        @utils.arg('--granularity', type=int, metavar='<GRANULARITY>',
                   dest=rule_namespace + '/granularity',
                   help='Length of each period (seconds) to evaluate over.')
        @utils.arg('--evaluation-periods', type=int, metavar='<COUNT>',
                   dest=rule_namespace + '/evaluation_periods',
                   help='Number of periods to evaluate over.')
        @utils.arg('--aggregation-method', metavar='<AGGREATION>',
                   dest=rule_namespace + '/aggregation_method',
                   help=('Aggregation method to use, one of: ' +
                         str(GNOCCHI_AGGREGATION) + '.'))
        @utils.arg('--comparison-operator', metavar='<OPERATOR>',
                   dest=rule_namespace + '/comparison_operator',
                   help=('Operator to compare with, one of: ' +
                         str(ALARM_OPERATORS) + '.'))
        @utils.arg('--threshold', type=float, metavar='<THRESHOLD>',
                   dest=rule_namespace + '/threshold',
                   required=create,
                   help='Threshold to evaluate against.')
        @functools.wraps(func)
        def _wrapped(*args, **kwargs):
            return func(*args, **kwargs)
        return _wrapped
    return _wrapper


def common_alarm_gnocchi_aggregation_by_metrics_arguments(create=False):
    def _wrapper(func):
        @utils.arg('-m', '--metrics', metavar='<METRICS>',
                   dest=('gnocchi_aggregation_by_metrics_threshold_rule/'
                         'metrics'),
                   action='append', required=create,
                   help='Metric to evaluate against.')
        @functools.wraps(func)
        def _wrapped(*args, **kwargs):
            return func(*args, **kwargs)
        return _wrapped
    return _wrapper


def common_alarm_gnocchi_aggregation_by_resources_arguments(create=False):
    def _wrapper(func):
        @utils.arg('-m', '--metric', metavar='<METRIC>',
                   dest=('gnocchi_aggregation_by_resources_threshold_rule/'
                         'metric'),
                   required=create,
                   help='Metric to evaluate against.')
        @utils.arg('--resource-type', metavar='<RESOURCE_TYPE>',
                   dest=('gnocchi_aggregation_by_resources_threshold_rule/'
                         'resource_type'),
                   required=create,
                   help='Resource_type to evaluate against.')
        @utils.arg('--query', metavar='<QUERY>',
                   dest=('gnocchi_aggregation_by_resources_threshold_rule/'
                         'query'),
                   required=create,
                   help=('Gnocchi resources search query filter'))
        @functools.wraps(func)
        def _wrapped(*args, **kwargs):
            return func(*args, **kwargs)
        return _wrapped
    return _wrapper


def common_alarm_gnocchi_resources_arguments(create=False):
    def _wrapper(func):
        @utils.arg('-m', '--metric', metavar='<METRIC>',
                   dest='gnocchi_resources_threshold_rule/metric',
                   required=create,
                   help='Metric to evaluate against.')
        @utils.arg('--resource-type', metavar='<RESOURCE_TYPE>',
                   dest='gnocchi_resources_threshold_rule/resource_type',
                   required=create,
                   help='Resource_type to evaluate against.')
        @utils.arg('--resource-id', metavar='<RESOURCE_ID>',
                   dest='gnocchi_resources_threshold_rule/resource_id',
                   required=create,
                   help=('Resource id to evaluate against'))
        @functools.wraps(func)
        def _wrapped(*args, **kwargs):
            return func(*args, **kwargs)
        return _wrapped
    return _wrapper


def common_alarm_event_arguments():
    def _wrapper(func):
        @utils.arg('--event-type', dest='event_rule/event_type',
                   metavar='<EVENT_TYPE>',
                   help='Event type for event alarm.')
        @utils.arg('-q', '--query', dest='event_rule/query', metavar='<QUERY>',
                   help=('key[op]data_type::value; list for filtering events. '
                         'data_type is optional, but if supplied must be '
                         'string, integer, float or datetime.'))
        @functools.wraps(func)
        def _wrapped(*args, **kwargs):
            return func(*args, **kwargs)
        return _wrapped
    return _wrapper


@common_alarm_arguments(create=True)
@utils.arg('--period', type=int, metavar='<PERIOD>',
           help='Length of each period (seconds) to evaluate over.')
@utils.arg('--evaluation-periods', type=int, metavar='<COUNT>',
           help='Number of periods to evaluate over.')
@utils.arg('-m', '--meter-name', metavar='<METRIC>', required=True,
           help='Metric to evaluate against.')
@utils.arg('--statistic', metavar='<STATISTIC>',
           help='Statistic to evaluate, one of: ' + str(STATISTICS) + '.')
@utils.arg('--comparison-operator', metavar='<OPERATOR>',
           help='Operator to compare with, one of: ' + str(ALARM_OPERATORS) +
           '.')
@utils.arg('--threshold', type=float, metavar='<THRESHOLD>', required=True,
           help='Threshold to evaluate against.')
@utils.arg('--matching-metadata', dest='matching_metadata',
           metavar='<Matching Metadata>', action='append', default=None,
           help=('A meter should match this resource metadata (key=value) '
                 'additionally to the meter_name.'))
@_restore_shadowed_arg('project_id', 'alarm_project_id')
@_restore_shadowed_arg('user_id', 'alarm_user_id')
def do_alarm_create(cc, args={}):
    """Create a new alarm (Deprecated). Use alarm-threshold-create instead."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, "time_constraints")
    fields = utils.args_array_to_dict(fields, "matching_metadata")
    alarm = cc.alarms.create(**fields)
    _display_alarm(alarm)


@common_alarm_arguments(create=True)
@common_alarm_gnocchi_arguments('gnocchi_resources_threshold_rule',
                                create=True)
@common_alarm_gnocchi_resources_arguments(create=True)
def do_alarm_gnocchi_resources_threshold_create(cc, args={}):
    """Create a new alarm based on computed statistics."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints')
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields['type'] = 'gnocchi_resources_threshold'
    alarm = cc.alarms.create(**fields)
    _display_alarm(alarm)


@common_alarm_arguments(create=True)
@common_alarm_gnocchi_arguments(
    'gnocchi_aggregation_by_metrics_threshold_rule', create=True)
@common_alarm_gnocchi_aggregation_by_metrics_arguments(create=True)
def do_alarm_gnocchi_aggregation_by_metrics_threshold_create(cc, args={}):
    """Create a new alarm based on computed statistics."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints')
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields['type'] = 'gnocchi_aggregation_by_metrics_threshold'
    alarm = cc.alarms.create(**fields)
    _display_alarm(alarm)


@common_alarm_arguments(create=True)
@common_alarm_gnocchi_arguments(
    'gnocchi_aggregation_by_resources_threshold_rule', create=True)
@common_alarm_gnocchi_aggregation_by_resources_arguments(create=True)
def do_alarm_gnocchi_aggregation_by_resources_threshold_create(cc, args={}):
    """Create a new alarm based on computed statistics."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints')
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields['type'] = 'gnocchi_aggregation_by_resources_threshold'
    alarm = cc.alarms.create(**fields)
    _display_alarm(alarm)


@common_alarm_arguments(create=True)
@utils.arg('-m', '--meter-name', metavar='<METRIC>', required=True,
           dest='threshold_rule/meter_name',
           help='Metric to evaluate against.')
@utils.arg('--period', type=int, metavar='<PERIOD>',
           dest='threshold_rule/period',
           help='Length of each period (seconds) to evaluate over.')
@utils.arg('--evaluation-periods', type=int, metavar='<COUNT>',
           dest='threshold_rule/evaluation_periods',
           help='Number of periods to evaluate over.')
@utils.arg('--statistic', metavar='<STATISTIC>',
           dest='threshold_rule/statistic',
           help='Statistic to evaluate, one of: ' + str(STATISTICS) + '.')
@utils.arg('--comparison-operator', metavar='<OPERATOR>',
           dest='threshold_rule/comparison_operator',
           help='Operator to compare with, one of: ' + str(ALARM_OPERATORS) +
           '.')
@utils.arg('--threshold', type=float, metavar='<THRESHOLD>', required=True,
           dest='threshold_rule/threshold',
           help='Threshold to evaluate against.')
@utils.arg('-q', '--query', metavar='<QUERY>',
           dest='threshold_rule/query',
           help='key[op]data_type::value; list. data_type is optional, '
                'but if supplied must be string, integer, float, or boolean.')
@_restore_shadowed_arg('project_id', 'alarm_project_id')
@_restore_shadowed_arg('user_id', 'alarm_user_id')
def do_alarm_threshold_create(cc, args={}):
    """Create a new alarm based on computed statistics."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints')
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields['type'] = 'threshold'
    if 'query' in fields['threshold_rule']:
        fields['threshold_rule']['query'] = options.cli_to_array(
            fields['threshold_rule']['query'])
    alarm = cc.alarms.create(**fields)
    _display_alarm(alarm)


@common_alarm_arguments(create=True)
@utils.arg('--alarm_ids', action='append', metavar='<ALARM IDS>',
           required=True, dest='combination_rule/alarm_ids',
           help='List of alarm IDs.')
@utils.arg('--operator', metavar='<OPERATOR>',
           dest='combination_rule/operator',
           help='Operator to compare with, one of: ' + str(
               ALARM_COMBINATION_OPERATORS) + '.')
@_restore_shadowed_arg('project_id', 'alarm_project_id')
@_restore_shadowed_arg('user_id', 'alarm_user_id')
def do_alarm_combination_create(cc, args={}):
    """Create a new alarm based on state of other alarms."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints')
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields['type'] = 'combination'
    alarm = cc.alarms.create(**fields)
    _display_alarm(alarm)


@common_alarm_arguments(create=True)
@common_alarm_event_arguments()
@_restore_shadowed_arg('project_id', 'alarm_project_id')
@_restore_shadowed_arg('user_id', 'alarm_user_id')
def do_alarm_event_create(cc, args={}):
    """Create a new alarm based on events."""
    fields = dict(filter(lambda x: x[1] is not None, vars(args).items()))
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields['type'] = 'event'
    fields['event_rule'] = fields.get('event_rule', {})
    if 'query' in fields['event_rule']:
        fields['event_rule']['query'] = options.cli_to_array(
            fields['event_rule']['query'])
    alarm = cc.alarms.create(**fields)
    _display_alarm(alarm)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm to update.')
@common_alarm_arguments()
@utils.arg('--remove-time-constraint', action='append',
           metavar='<Constraint names>',
           dest='remove_time_constraints',
           help='Name or list of names of the time constraints to remove.')
@utils.arg('--period', type=int, metavar='<PERIOD>',
           help='Length of each period (seconds) to evaluate over.')
@utils.arg('--evaluation-periods', type=int, metavar='<COUNT>',
           help='Number of periods to evaluate over.')
@utils.arg('-m', '--meter-name', metavar='<METRIC>',
           help='Metric to evaluate against.')
@utils.arg('--statistic', metavar='<STATISTIC>',
           help='Statistic to evaluate, one of: ' + str(STATISTICS))
@utils.arg('--comparison-operator', metavar='<OPERATOR>',
           help='Operator to compare with, one of: ' + str(ALARM_OPERATORS) +
           '.')
@utils.arg('--threshold', type=float, metavar='<THRESHOLD>',
           help='Threshold to evaluate against.')
@utils.arg('--matching-metadata', dest='matching_metadata',
           metavar='<Matching Metadata>', action='append', default=None,
           help=('A meter should match this resource metadata (key=value) '
                 'additionally to the meter_name.'))
@_restore_shadowed_arg('project_id', 'alarm_project_id')
@_restore_shadowed_arg('user_id', 'alarm_user_id')
def do_alarm_update(cc, args={}):
    """Update an existing alarm (Deprecated)."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, "time_constraints")
    fields = utils.args_array_to_dict(fields, "matching_metadata")
    fields.pop('alarm_id')
    try:
        alarm = cc.alarms.update(args.alarm_id, **fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    _display_alarm(alarm)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm to update.')
@common_alarm_arguments()
@utils.arg('--remove-time-constraint', action='append',
           metavar='<Constraint names>',
           dest='remove_time_constraints',
           help='Name or list of names of the time constraints to remove.')
@utils.arg('-m', '--meter-name', metavar='<METRIC>',
           dest='threshold_rule/meter_name',
           help='Metric to evaluate against.')
@utils.arg('--period', type=int, metavar='<PERIOD>',
           dest='threshold_rule/period',
           help='Length of each period (seconds) to evaluate over.')
@utils.arg('--evaluation-periods', type=int, metavar='<COUNT>',
           dest='threshold_rule/evaluation_periods',
           help='Number of periods to evaluate over.')
@utils.arg('--statistic', metavar='<STATISTIC>',
           dest='threshold_rule/statistic',
           help='Statistic to evaluate, one of: ' + str(STATISTICS) +
           '.')
@utils.arg('--comparison-operator', metavar='<OPERATOR>',
           dest='threshold_rule/comparison_operator',
           help='Operator to compare with, one of: ' + str(ALARM_OPERATORS) +
           '.')
@utils.arg('--threshold', type=float, metavar='<THRESHOLD>',
           dest='threshold_rule/threshold',
           help='Threshold to evaluate against.')
@utils.arg('-q', '--query', metavar='<QUERY>',
           dest='threshold_rule/query',
           help='key[op]data_type::value; list. data_type is optional, '
                'but if supplied must be string, integer, float, or boolean.')
@_restore_shadowed_arg('project_id', 'alarm_project_id')
@_restore_shadowed_arg('user_id', 'alarm_user_id')
def do_alarm_threshold_update(cc, args={}):
    """Update an existing alarm based on computed statistics."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints')
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields.pop('alarm_id')
    fields['type'] = 'threshold'
    if 'threshold_rule' in fields and 'query' in fields['threshold_rule']:
        fields['threshold_rule']['query'] = options.cli_to_array(
            fields['threshold_rule']['query'])
    try:
        alarm = cc.alarms.update(args.alarm_id, **fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    _display_alarm(alarm)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm to update.')
@common_alarm_arguments()
@common_alarm_gnocchi_arguments('gnocchi_resources_threshold_rule')
@common_alarm_gnocchi_resources_arguments()
@utils.arg('--remove-time-constraint', action='append',
           metavar='<Constraint names>',
           dest='remove_time_constraints',
           help='Name or list of names of the time constraints to remove.')
def do_alarm_gnocchi_resources_threshold_update(cc, args={}):
    """Update an existing alarm based on computed statistics."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints')
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields.pop('alarm_id')
    fields['type'] = 'gnocchi_resources_threshold'
    try:
        alarm = cc.alarms.update(args.alarm_id, **fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    _display_alarm(alarm)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm to update.')
@common_alarm_arguments()
@common_alarm_gnocchi_arguments(
    'gnocchi_aggregation_by_metrics_threshold_rule')
@common_alarm_gnocchi_aggregation_by_metrics_arguments()
@utils.arg('--remove-time-constraint', action='append',
           metavar='<Constraint names>',
           dest='remove_time_constraints',
           help='Name or list of names of the time constraints to remove.')
def do_alarm_gnocchi_aggregation_by_metrics_threshold_update(cc, args={}):
    """Update an existing alarm based on computed statistics."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints')
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields.pop('alarm_id')
    fields['type'] = 'gnocchi_aggregation_by_metrics_threshold'
    try:
        alarm = cc.alarms.update(args.alarm_id, **fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    _display_alarm(alarm)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm to update.')
@common_alarm_arguments()
@common_alarm_gnocchi_arguments(
    'gnocchi_aggregation_by_resources_threshold_rule')
@common_alarm_gnocchi_aggregation_by_resources_arguments()
@utils.arg('--remove-time-constraint', action='append',
           metavar='<Constraint names>',
           dest='remove_time_constraints',
           help='Name or list of names of the time constraints to remove.')
def do_alarm_gnocchi_aggregation_by_resources_threshold_update(cc, args={}):
    """Update an existing alarm based on computed statistics."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints')
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields.pop('alarm_id')
    fields['type'] = 'gnocchi_aggregation_by_resources_threshold'
    try:
        alarm = cc.alarms.update(args.alarm_id, **fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    _display_alarm(alarm)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm to update.')
@common_alarm_arguments()
@utils.arg('--remove-time-constraint', action='append',
           metavar='<Constraint names>',
           dest='remove_time_constraints',
           help='Name or list of names of the time constraints to remove.')
@utils.arg('--alarm_ids', action='append', metavar='<ALARM IDS>',
           dest='combination_rule/alarm_ids',
           help='List of alarm IDs.')
@utils.arg('--operator', metavar='<OPERATOR>',
           dest='combination_rule/operator',
           help='Operator to compare with, one of: ' + str(
               ALARM_COMBINATION_OPERATORS) + '.')
@_restore_shadowed_arg('project_id', 'alarm_project_id')
@_restore_shadowed_arg('user_id', 'alarm_user_id')
def do_alarm_combination_update(cc, args={}):
    """Update an existing alarm based on state of other alarms."""
    fields = dict(filter(lambda x: not (x[1] is None), vars(args).items()))
    fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints')
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields.pop('alarm_id')
    fields['type'] = 'combination'
    try:
        alarm = cc.alarms.update(args.alarm_id, **fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    _display_alarm(alarm)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm to update.')
@common_alarm_arguments()
@common_alarm_event_arguments()
@_restore_shadowed_arg('project_id', 'alarm_project_id')
@_restore_shadowed_arg('user_id', 'alarm_user_id')
def do_alarm_event_update(cc, args={}):
    """Update an existing alarm based on events."""
    fields = dict(filter(lambda x: x[1] is not None, vars(args).items()))
    fields = utils.key_with_slash_to_nested_dict(fields)
    fields.pop('alarm_id')
    fields['type'] = 'event'
    if fields.get('event_rule') and 'query' in fields['event_rule']:
        fields['event_rule']['query'] = options.cli_to_array(
            fields['event_rule']['query'])
    try:
        alarm = cc.alarms.update(args.alarm_id, **fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    _display_alarm(alarm)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm to delete.')
def do_alarm_delete(cc, args={}):
    """Delete an alarm."""
    try:
        cc.alarms.delete(args.alarm_id)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm state to set.')
@utils.arg('--state', metavar='<STATE>', required=True,
           help='State of the alarm, one of: ' + str(ALARM_STATES) +
           '.')
def do_alarm_state_set(cc, args={}):
    """Set the state of an alarm."""
    try:
        state = cc.alarms.set_state(args.alarm_id, args.state)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    utils.print_dict({'state': state}, wrap=72)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?',
           action=NotEmptyAction, help='ID of the alarm state to show.')
def do_alarm_state_get(cc, args={}):
    """Get the state of an alarm."""
    try:
        state = cc.alarms.get_state(args.alarm_id)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    utils.print_dict({'state': state}, wrap=72)


@utils.arg('-a', '--alarm_id', metavar='<ALARM_ID>',
           action=obsoleted_by('alarm_id'), help=argparse.SUPPRESS,
           dest='alarm_id_deprecated')
@utils.arg('alarm_id', metavar='<ALARM_ID>', nargs='?', action=NotEmptyAction,
           help='ID of the alarm for which history is shown.')
@utils.arg('-q', '--query', metavar='<QUERY>',
           help='key[op]data_type::value; list. data_type is optional, '
                'but if supplied must be string, integer, float, or boolean.')
def do_alarm_history(cc, args={}):
    """Display the change history of an alarm."""
    kwargs = dict(alarm_id=args.alarm_id,
                  q=options.cli_to_array(args.query))
    try:
        history = cc.alarms.get_history(**kwargs)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm not found: %s' % args.alarm_id)
    field_labels = ['Type', 'Timestamp', 'Detail']
    fields = ['type', 'timestamp', 'detail']
    # We're using sortby=None as the alarm history returned from the Ceilometer
    # is already sorted in the "the newer state is the earlier one in the
    # list". If we'll pass any field as a sortby param, it'll be sorted in the
    # ASC way by the PrettyTable
    utils.print_list(history, fields, field_labels,
                     formatters={'detail': alarm_change_detail_formatter},
                     sortby=None)


@utils.arg('-q', '--query', metavar='<QUERY>',
           help='key[op]data_type::value; list. data_type is optional, '
                'but if supplied must be string, integer, float, or boolean.')
@utils.arg('--meter-links', dest='meter_links', action='store_true',
           help='If specified, meter links will be generated.')
@utils.arg('-l', '--limit', metavar='<NUMBER>',
           help='Maximum number of resources to return. %s' %
           DEFAULT_API_LIMIT)
def do_resource_list(cc, args={}):
    """List the resources."""
    resources = cc.resources.list(q=options.cli_to_array(args.query),
                                  links=args.meter_links,
                                  limit=args.limit)

    field_labels = ['Resource ID', 'Source', 'User ID', 'Project ID']
    fields = ['resource_id', 'source', 'user_id', 'project_id']
    utils.print_list(resources, fields, field_labels,
                     sortby=1)


@utils.arg('resource_id', metavar='<RESOURCE_ID>',
           action=NotEmptyAction, help='ID of the resource to show.')
def do_resource_show(cc, args={}):
    """Show the resource."""
    try:
        resource = cc.resources.get(args.resource_id)
    except exc.HTTPNotFound:
        raise exc.CommandError('Resource not found: %s' % args.resource_id)
    else:
        fields = ['resource_id', 'source', 'user_id',
                  'project_id', 'metadata']
        data = dict([(f, getattr(resource, f, '')) for f in fields])
        utils.print_dict(data, wrap=72)


@utils.arg('-q', '--query', metavar='<QUERY>',
           help='key[op]data_type::value; list. data_type is optional, '
                'but if supplied must be string, integer, float'
                'or datetime.')
@utils.arg('--no-traits', dest='no_traits', action='store_true',
           help='If specified, traits will not be printed.')
@utils.arg('-l', '--limit', metavar='<NUMBER>',
           help='Maximum number of events to return. %s' % DEFAULT_API_LIMIT)
def do_event_list(cc, args={}):
    """List events."""
    events = cc.events.list(q=options.cli_to_array(args.query),
                            limit=args.limit)
    field_labels = ['Message ID', 'Event Type', 'Generated', 'Traits']
    fields = ['message_id', 'event_type', 'generated', 'traits']
    if args.no_traits:
        field_labels.pop()
        fields.pop()
    utils.print_list(events, fields, field_labels,
                     formatters={
                         'traits': utils.nested_list_of_dict_formatter(
                             'traits', ['name', 'type', 'value']
                         )},
                     sortby=None)


@utils.arg('message_id', metavar='<message_id>', action=NotEmptyAction,
           help='The ID of the event. Should be a UUID.')
def do_event_show(cc, args={}):
    """Show a particular event."""
    try:
        event = cc.events.get(args.message_id)
    except exc.HTTPNotFound:
        raise exc.CommandError('Event not found: %s' % args.message_id)

    fields = ['event_type', 'generated', 'traits', 'raw']
    data = dict([(f, getattr(event, f, '')) for f in fields])
    utils.print_dict(data, wrap=72)


def do_event_type_list(cc, args={}):
    """List event types."""
    event_types = cc.event_types.list()
    utils.print_list(event_types, ['event_type'], ['Event Type'])


@utils.arg('-e', '--event_type', metavar='<EVENT_TYPE>',
           help='Type of the event for which traits will be shown.',
           required=True, action=NotEmptyAction)
def do_trait_description_list(cc, args={}):
    """List trait info for an event type."""
    trait_descriptions = cc.trait_descriptions.list(args.event_type)
    field_labels = ['Trait Name', 'Data Type']
    fields = ['name', 'type']
    utils.print_list(trait_descriptions, fields, field_labels)


@utils.arg('-e', '--event_type', metavar='<EVENT_TYPE>',
           help='Type of the event for which traits will listed.',
           required=True, action=NotEmptyAction)
@utils.arg('-t', '--trait_name', metavar='<TRAIT_NAME>',
           help='The name of the trait to list.',
           required=True, action=NotEmptyAction)
def do_trait_list(cc, args={}):
    """List all traits with name <trait_name> for Event Type <event_type>."""
    traits = cc.traits.list(args.event_type, args.trait_name)
    field_labels = ['Trait Name', 'Value', 'Data Type']
    fields = ['name', 'value', 'type']
    utils.print_list(traits, fields, field_labels)


@utils.arg('-f', '--filter', metavar='<FILTER>',
           help=('{complex_op: [{simple_op: {field_name: value}}]} '
                 'The complex_op is one of: ' + str(COMPLEX_OPERATORS) + ', '
                 'simple_op is one of: ' + str(SIMPLE_OPERATORS) + '.'))
@utils.arg('-o', '--orderby', metavar='<ORDERBY>',
           help=('[{field_name: direction}, {field_name: direction}] '
                 'The direction is one of: ' + str(ORDER_DIRECTIONS) + '.'))
@utils.arg('-l', '--limit', metavar='<LIMIT>',
           help='Maximum number of samples to return. %s' % DEFAULT_API_LIMIT)
def do_query_samples(cc, args):
    """Query samples."""
    fields = {'filter': args.filter,
              'orderby': args.orderby,
              'limit': args.limit}
    try:
        samples = cc.query_samples.query(**fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Samples not found')
    else:
        field_labels = ['ID', 'Resource ID', 'Meter', 'Type', 'Volume',
                        'Unit', 'Timestamp']
        fields = ['id', 'resource_id', 'meter', 'type',
                  'volume', 'unit', 'timestamp']
        utils.print_list(samples, fields, field_labels,
                         sortby=None)


@utils.arg('-f', '--filter', metavar='<FILTER>',
           help=('{complex_op: [{simple_op: {field_name: value}}]} '
                 'The complex_op is one of: ' + str(COMPLEX_OPERATORS) + ', '
                 'simple_op is one of: ' + str(SIMPLE_OPERATORS) + '.'))
@utils.arg('-o', '--orderby', metavar='<ORDERBY>',
           help=('[{field_name: direction}, {field_name: direction}] '
                 'The direction is one of: ' + str(ORDER_DIRECTIONS) + '.'))
@utils.arg('-l', '--limit', metavar='<LIMIT>',
           help='Maximum number of alarms to return. %s' % DEFAULT_API_LIMIT)
def do_query_alarms(cc, args):
    """Query Alarms."""
    fields = {'filter': args.filter,
              'orderby': args.orderby,
              'limit': args.limit}
    try:
        alarms = cc.query_alarms.query(**fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarms not found')
    else:
        _display_alarm_list(alarms, sortby=None)


@utils.arg('-f', '--filter', metavar='<FILTER>',
           help=('{complex_op: [{simple_op: {field_name: value}}]} '
                 'The complex_op is one of: ' + str(COMPLEX_OPERATORS) + ', '
                 'simple_op is one of: ' + str(SIMPLE_OPERATORS) + '.'))
@utils.arg('-o', '--orderby', metavar='<ORDERBY>',
           help=('[{field_name: direction}, {field_name: direction}] '
                 'The direction is one of: ' + str(ORDER_DIRECTIONS) + '.'))
@utils.arg('-l', '--limit', metavar='<LIMIT>',
           help='Maximum number of alarm history items to return. %s' %
           DEFAULT_API_LIMIT)
def do_query_alarm_history(cc, args):
    """Query Alarm History."""
    fields = {'filter': args.filter,
              'orderby': args.orderby,
              'limit': args.limit}
    try:
        alarm_history = cc.query_alarm_history.query(**fields)
    except exc.HTTPNotFound:
        raise exc.CommandError('Alarm history not found')
    else:
        field_labels = ['Alarm ID', 'Event ID', 'Type', 'Detail', 'Timestamp']
        fields = ['alarm_id', 'event_id', 'type', 'detail', 'timestamp']
        utils.print_list(alarm_history, fields, field_labels,
                         formatters={'rule': alarm_change_detail_formatter},
                         sortby=None)


def do_capabilities(cc, args):
    """Print Ceilometer capabilities."""
    capabilities = cc.capabilities.get().to_dict()
    # Capability is a nested dict, and has no user defined data,
    # so it is safe to format here with json tools.
    for key in capabilities:
        # remove the leading and trailing pair of {}
        capabilities[key] = jsonutils.dumps(capabilities[key],
                                            sort_keys=True, indent=0)[2:-2]
    utils.print_dict(capabilities)
