# -*- coding: utf8 -*-
#
#    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 copy

from django.utils.http import urlencode
from django.utils.translation import ugettext_lazy as _
from horizon import exceptions
from openstack_dashboard.api import ceilometer
from openstack_dashboard.utils import metering

SETTINGS = {
    'settings': {
        'renderer': 'StaticAxes',
        'xMin': None,
        'xMax': None,
        'higlight_last_point': True,
        'auto_size': False,
        'auto_resize': False,
        'axes_x': False,
        'axes_y': True,
        'axes_y_label': False,
        'bar_chart_settings': {
            'orientation': 'vertical',
            'used_label_placement': 'left',
            'width': 30,
            'color_scale_domain': [0, 80, 80, 100],
            'color_scale_range': [
                '#0000FF',
                '#0000FF',
                '#FF0000',
                '#FF0000'
            ],
            'average_color_scale_domain': [0, 100],
            'average_color_scale_range': ['#0000FF', '#0000FF']
        }
    },
    'stats': {
        'average': None,
        'used': None,
        'tooltip_average': None,
    }
}

LABELS = {
    'hardware.cpu.load.1min': _("CPU load 1 min average"),
    'hardware.system_stats.cpu.util': _("CPU utilization"),
    'hardware.system_stats.io.outgoing.blocks': _("IO raw sent"),
    'hardware.system_stats.io.incoming.blocks': _("IO raw received"),
    'hardware.network.ip.outgoing.datagrams': _("IP out requests"),
    'hardware.network.ip.incoming.datagrams': _("IP in requests"),
    'hardware.memory.swap.util': _("Swap utilization"),
    'hardware.ipmi.fan': _("Fan Speed"),
    'hardware.ipmi.voltage': _("Voltage"),
    'hardware.ipmi.temperature': _("Temperature"),
    'hardware.ipmi.current': _("Current")
}


# TODO(lsmola) this should probably live in Horizon common
def query_data(request,
               date_from,
               date_to,
               group_by,
               meter,
               period=None,
               query=None,
               additional_query=None):

    if not period:
        period = metering.calc_period(date_from, date_to, 50)
    if additional_query is None:
        additional_query = []
    if date_from:
        additional_query += [{'field': 'timestamp',
                              'op': 'ge',
                              'value': date_from}]
    if date_to:
        additional_query += [{'field': 'timestamp',
                              'op': 'le',
                              'value': date_to}]

    # TODO(lsmola) replace this by logic implemented in I1 in bugs
    # 1226479 and 1226482, this is just a quick fix for RC1
    ceilometer_usage = ceilometer.CeilometerUsage(request)
    try:
        if group_by:
            resources = ceilometer_usage.resource_aggregates_with_statistics(
                query, [meter], period=period, stats_attr=None,
                additional_query=additional_query)
        else:
            resources = ceilometer_usage.resources_with_statistics(
                query, [meter], period=period, stats_attr=None,
                additional_query=additional_query)
    except Exception:
        resources = []
        exceptions.handle(request,
                          _('Unable to retrieve statistics.'))
    return resources


def url_part(meter_name, barchart):
    d = {'meter': meter_name}
    if barchart:
        d['barchart'] = True
    return urlencode(d)


def get_meter_name(meter):
    return meter.replace('.', '_')


def get_meter_list_and_unit(request, meter):
    try:
        meter_list = [m for m in ceilometer.meter_list(request)
                      if m.name == meter]
        unit = meter_list[0].unit
    except Exception:
        meter_list = []
        unit = ''

    return meter_list, unit


def get_meters(meters):
    return [(m, get_meter_name(m)) for m in meters]


def get_barchart_stats(series, unit):
    values = [point['y'] for point in series[0]['data']]
    average = sum(values) / len(values)
    used = values[-1]
    first_date = series[0]['data'][0]['x']
    last_date = series[0]['data'][-1]['x']
    tooltip_average = _('Average %(average)s %(unit)s<br> From: '
                        '%(first_date)s, to: %(last_date)s') % (
                            dict(average=average, unit=unit,
                                 first_date=first_date,
                                 last_date=last_date))
    return average, used, tooltip_average


def create_json_output(series, barchart, unit, date_from, date_to):
    start_datetime = end_datetime = ''
    if date_from:
        start_datetime = date_from.strftime("%Y-%m-%dT%H:%M:%S")
    if date_to:
        end_datetime = date_to.strftime("%Y-%m-%dT%H:%M:%S")

    settings = copy.deepcopy(SETTINGS)
    settings['settings']['xMin'] = start_datetime
    settings['settings']['xMax'] = end_datetime

    if series and barchart:
        average, used, tooltip_average = get_barchart_stats(series, unit)
        settings['settings']['yMin'] = 0
        settings['settings']['yMax'] = 100
        settings['stats']['average'] = average
        settings['stats']['used'] = used
        settings['stats']['tooltip_average'] = tooltip_average
    else:
        del settings['settings']['bar_chart_settings']
        del settings['stats']

    json_output = {'series': series}
    json_output = dict(json_output.items() + settings.items())
    return json_output


def get_nodes_stats(request, node_uuid, instance_uuid, meter,
                    date_options=None, date_from=None, date_to=None,
                    stats_attr=None, barchart=None, group_by=None):
    series = []
    meter_list, unit = get_meter_list_and_unit(request, meter)

    if instance_uuid:
        if 'ipmi' in meter:
            # For IPMI metrics, a resource ID is made of node UUID concatenated
            # with the metric description. E.g:
            # 1dcf1896-f581-4027-9efa-973eef3380d2-fan_2a_tach_(0x42)
            resource_ids = [m.resource_id for m in meter_list
                            if m.resource_id.startswith(node_uuid)]
            queries = [
                [{'field': 'resource_id',
                  'op': 'eq',
                  'value': resource_id}]
                for resource_id in resource_ids
            ]
        else:
            # For SNMP metrics, a resource ID matches exactly the UUID of the
            # associated instance
            if group_by == "image_id":
                query = {}
                image_query = [{"field": "metadata.%s" % group_by,
                                "op": "eq",
                                "value": instance_uuid}]
                query[instance_uuid] = image_query
            else:
                query = [{'field': 'resource_id',
                          'op': 'eq',
                          'value': instance_uuid}]
            queries = [query]
    else:
        # query will be aggregated across all resources
        group_by = "all"
        query = {'all': []}
        queries = [query]

    # Disk and Network I/O: data from 2 meters in one chart
    if meter == 'disk-io':
        meters = get_meters([
            'hardware.system_stats.io.outgoing.blocks',
            'hardware.system_stats.io.incoming.blocks'
        ])
    elif meter == 'network-io':
        meters = get_meters([
            'hardware.network.ip.outgoing.datagrams',
            'hardware.network.ip.incoming.datagrams'
        ])
    else:
        meters = get_meters([meter])

    date_from, date_to = metering.calc_date_args(
        date_from,
        date_to,
        date_options)

    for meter_id, meter_name in meters:
        label = unicode(LABELS.get(meter_id, meter_name))

        for query in queries:
            resources = query_data(
                request=request,
                date_from=date_from,
                date_to=date_to,
                group_by=group_by,
                meter=meter_id,
                query=query)
            s = metering.series_for_meter(request, resources, group_by,
                                          meter_id, meter_name, stats_attr,
                                          unit, label)
            series += s

    series = metering.normalize_series_by_unit(series)

    json_output = create_json_output(
        series,
        barchart,
        unit,
        date_from,
        date_to)

    return json_output


def get_top_5(request, meter):
    ceilometer_usage = ceilometer.CeilometerUsage(request)
    meter_list, unit = get_meter_list_and_unit(request, meter)
    top_5 = {'unit': unit, 'label': LABELS.get(meter, meter)}
    data = []

    for m in meter_list:
        query = [{'field': 'resource_id', 'op': 'eq', 'value': m.resource_id}]
        resource = ceilometer_usage.resources_with_statistics(query, [m.name],
                                                              period=600)[0]
        node_uuid = resource.metadata['node']
        old_value, value = resource.get_meter(get_meter_name(m.name))[-2:]
        old_value, value = old_value.max, value.max

        if value > old_value:
            direction = 'up'
        elif value < old_value:
            direction = 'down'
        else:
            direction = None

        data.append({
            'node_uuid': node_uuid,
            'value': value,
            'direction': direction
        })

    top_5['data'] = sorted(data, key=lambda d: d['value'], reverse=True)[:5]
    return top_5