# SPDX-License-Identifier: EPL-1.0
##############################################################################
# Copyright (c) 2018 The Linux Foundation and others.
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/epl-v10.html
##############################################################################
import yaml
from copy import deepcopy as dc

import json

# Pretty Printer


def p(x):
    print(json.dumps(x, indent=4, sort_keys=True))


class visState:
    # viState template
    def __init__(self):
        self.content = {
            'title': None,
            'type': None,
            'params': {
                'type': None,
                'grid': {
                    'categoryLines': False,
                    'style': {
                        'color': '#eee'
                    }
                },
                'categoryAxes': None,
                'valueAxes': None,
                'seriesParams': None,
                'addTooltip': True,
                'addLegend': True,
                'legendPosition': 'right',
                'times': [],
                'addTimeMarker': False
            },
            'aggs': None
        }

    def create(self, config):
        temp = self.content
        temp['title'] = config['title']
        temp['type'] = temp['params']['type'] = config['type']

        cat = categoryAxes()
        temp['params']['categoryAxes'] = [dc(
            cat.create()) for i in range(config['num_cat_axes'])]

        val = ValueAxes()
        temp['params']['valueAxes'] = [dc(val.create(position=i['position'],
                                                     title=i['title']))
                                       for _, i in
                                       config['value_axes'].items()]

        agg = aggs()

        temp['aggs'] = \
            [dc(agg.create(id=i,
                           field=config['aggs'][i]['field'],
                           custom_label=config['aggs'][i]['custom_label'],
                           schema=config['aggs'][i]['schema']))
             for i in range(1, len(config['aggs']) + 1)]

        temp['params']['seriesParams'] = [seriesParams(i['data_type'],
                                                       i['mode'],
                                                       i['label'],
                                                       i['agg_id'],
                                                       i['value_axis'])
                                          .create()
                                          for _, i in
                                          config['seriesParams'].items()]

        return temp


class categoryAxes:
    def __init__(self):
        self.content = {
            'id': None,
            'type': 'category',
            'position': 'bottom',
            'show': True,
            'style': {},
            'scale': {
                'type': 'linear'
            },
            'labels': {
                'show': True,
                'truncate': 100
            },
            'title': {}
        }
        self.counter = 0

    # Category axes are named as CategoryAxis-i
    def create(self):
        self.counter += 1
        temp = dc(self.content)
        temp['id'] = 'CategoryAxis-{}'.format(self.counter)
        return temp


class ValueAxes:
    def __init__(self):
        self.content = {
            'id': None,
            'name': None,
            'type': 'value',
            'position': 'left',
            'show': True,
            'style': {},
            'scale': {
                'type': 'linear',
                'mode': 'normal'
            },
            'labels': {
                'show': True,
                'rotate': 0,
                'filter': False,
                'truncate': 100
            },
            'title': {
                'text': None
            }
        }
        self.counter = 0

    def create(self, position='left', title='Value'):
        self.counter += 1
        temp = dc(self.content)
        temp['id'] = 'ValueAxis-{}'.format(self.counter)
        if position == 'left':
            temp['name'] = 'LeftAxis-{}'.format(self.counter)
        elif position == 'right':
            temp['name'] = 'RightAxis-{}'.format(self.counter)
        else:
            # raise ValueError('Not one of left or right')
            # assuming default
            temp['name'] = 'LeftAxis-{}'.format(self.counter)

        temp['title']['text'] = title

        return temp

# 'seriesParams' are the ones that actually show up in the plots.
# They point to a data source a.k.a 'aggs' (short for aggregation)
# to get their data.


class seriesParams:
    def __init__(self, data_type, mode, label, agg_id, value_axis):
        self.content = {
            'show': True,
            'type': data_type,
            'mode': mode,
            'data': {
                'label': label,
                'id': str(agg_id)  # the id of the aggregation they point to
            },
            'valueAxis': 'ValueAxis-{}'.format(value_axis),
            'drawLinesBetweenPoints': True,
            'showCircles': True
        }

    def create(self):
        return self.content

# 'aggs' or aggregation refers to collection of values. They are the data
# source which are used by seriesParams. and as expected they take 'field'
# as the nested name of the key.
#
# Example, if your value is in {
#  'perfomance': {
#  'plots': {
#         'rate': myval,
#          ...
#        }
#   },
#   then I would have to use, 'performance.plots.rate' as the 'field' for aggs
# the 'schema' of an agg is 'metric' which are to be
# plotted in the Y-axis and 'segment' for the ones in X-axis


class aggs:
    def __init__(self):
        self.content = {
            'id': None,
            'enabled': True,
            'type': None,
            'schema': None,
            'params': {
                'field': None,
                'customLabel': None
            }
        }
        self.counter = 0

    def create(self, id, field, custom_label, schema):
        temp = dc(self.content)
        temp['id'] = id
        temp['params']['field'] = field
        temp['params']['customLabel'] = custom_label
        temp['schema'] = schema
        if schema == 'metric':
            temp['type'] = 'max'
            return temp
        elif schema == 'segment':
            temp['type'] = 'terms'
            temp['params']['size'] = 20  # default
            temp['params']['order'] = 'asc'
            temp['params']['orderBy'] = '_term'
        return temp


# 'series' actually combines and simplifies both 'seriesParams' and 'aggs'
# Both 'seriesParams' and 'aggs' support 'default' to set default values

# generate takes both the template config and project specific config and
# parses and organizes as much info available from that and
# generates an intermediate format first which
# contains all necessary info to deterministically create the visState to
# be sent to Kibana. Hence, any error occuring in the visualizaton side
# must first be checked by looking at the intermediate format.

def generate(dash_config, viz_config):

    format = {
        "type": None,
        "value_axes": {},
        "seriesParams": {},
        "index_pattern": None,
        "desc": None,
        "id": None,
        "aggs": {},
        "title": None,
        "num_cat_axes": None
    }

    value_axes_format = {
        "index": {
            "position": None,
            "title": None
        }
    }

    seriesParams_format = {
        "index": {
            "value_axis": None,
            "data_type": None,
            "mode": None,
            "label": None,
            "agg_id": None
        }
    }

    aggs_format = {
        "index": {
            "custom_label": None,
            "field": None,
            "schema": None
        }
    }

    # all general description must be present in either of the config files
    for config in [viz_config, dash_config]:
        general_fields = ['type', 'index_pattern',
                          'num_cat_axes', 'title', 'desc', 'id']
        for i in general_fields:
            try:
                format[i] = config[i]
            except KeyError as e:
                pass

    # setting any default values if available
    mappings = {'value_axes': value_axes_format,
                'seriesParams': seriesParams_format, 'aggs': aggs_format}
    for index, container in mappings.items():
        try:
            default_values = viz_config[index]['default']
            for i in default_values:
                container['index'][i] = default_values[i]
        except Exception:
            pass

    ####################################################################
    # Extract 'value_axes', 'seriesParams' or 'aggs' if present in viz_config
    value_axes_counter = 1
    for m in viz_config['value_axes']:
        if m != "default":
            temp = dc(value_axes_format)
            temp[str(value_axes_counter)] = temp['index']
            for i in ['position', 'title']:
                try:
                    temp[str(value_axes_counter)
                         ][i] = viz_config['value_axes'][m][i]
                except KeyError:
                    pass
            format['value_axes'].update(temp)
            value_axes_counter += 1

    seriesParams_fields = ['value_axis',
                           'data_type', 'mode', 'label', 'agg_id']
    try:
        for m in viz_config['seriesParams']:
            if m != 'default':
                temp = dc(seriesParams_format)
                temp[m] = temp['index']
                for i in seriesParams_fields:
                    try:
                        temp[m][i] = viz_config['seriesParams'][m][i]
                    except KeyError:
                        pass
                format['seriesParams'].update(temp)
    except KeyError:
        pass

    agg_counter = 1
    try:
        for m in viz_config['aggs']:
            if m != 'default':
                temp = dc(aggs_format)
                temp[m] = temp['index']
                for i in ['field', 'custom_label', 'schema']:
                    try:
                        temp[m][i] = viz_config['aggs'][m][i]
                    except KeyError:
                        pass
                format['aggs'].update(temp)
    except KeyError:
        pass
    ####################################################################

    # collect 'series' from both the configs
    configs = []
    try:
        viz_config['series']
        configs.append(viz_config)
    except KeyError:
        pass

    try:
        dash_config['y-axis']['series']
        configs.append(dash_config['y-axis'])
    except KeyError:
        pass

    ########################################################################
    # Extract 'series' from either of the configs
    for config in configs:
        try:
            value_axes_counter = 1
            for key in config['value_axes']:

                value_axes_temp = dc(value_axes_format)
                value_axes_temp[str(value_axes_counter)
                                ] = value_axes_temp['index']

                for index in ['position', 'title']:
                    try:
                        value_axes_temp[str(
                            value_axes_counter)][index] = \
                            config['value_axes'][key][index]
                    except KeyError as e:
                        pass
                format['value_axes'].update(value_axes_temp)
                value_axes_counter += 1

        except KeyError as e:
            pass

        try:
            for key in config['series']:
                try:
                    # check if this key is present or not
                    config['series'][key]['not_in_seriesParams']
                except KeyError:
                    seriesParams_temp = dc(seriesParams_format)
                    seriesParams_temp[key] = seriesParams_temp['index']
                    for index in ['value_axis', 'data_type', 'mode', 'label']:
                        try:
                            seriesParams_temp[key][index] = \
                                config['series'][key][index]
                        except KeyError as e:
                            pass
                    seriesParams_temp[key]['agg_id'] = key
                    format['seriesParams'].update(seriesParams_temp)
                finally:
                    agg_temp = dc(aggs_format)
                    agg_temp[key] = agg_temp['index']
                    for index in ['field', 'schema']:
                        try:
                            agg_temp[key][index] = config['series'][key][index]
                        except KeyError as e:
                            pass
                    agg_temp[key]['custom_label'] = \
                        config['series'][key]['label']
                    format['aggs'].update(agg_temp)
        except KeyError as e:
            print("required fields are empty!")

    ##########################################################################

    # to remove the default template index
    for i in ['value_axes', 'seriesParams', 'aggs']:
        try:
            format[i].pop('index')
        except KeyError:
            # print("No default index found")
            pass

    missing = config_validator(format)
    if len(missing):
        raise ValueError('Missing required field values :-', *missing)

    p(format)

    vis = visState()
    generated_visState = vis.create(format)

    # checking incase there are None values
    # in the format indicating missing fields

    missing = config_validator(generated_visState)
    if len(missing):
        raise ValueError('required fields are missing values! ', *missing)
    return format, generated_visState


# Check the generated format if it contains any key with None
# as it's value which indicates incomplete information

def config_validator(val, missing=[]):
    for key, value in val.items():
        if isinstance(value, dict):
            config_validator(value)
        if value is None:
            missing.append(key)
    return missing


if __name__ == '__main__':
    with open('viz_config.yaml', 'r') as f:
        viz_config = yaml.safe_load(f)

    with open('dash_config.yaml', 'r') as f:
        dash_config = yaml.safe_load(f)

    generate(dash_config['dashboard']['viz'][2],
             viz_config['opendaylight-test-performance'])
    # generate(dash_config['dashboard']['viz'][3],viz_config['opendaylight-test-performance'])
    # generate(dash_config['dashboard']['viz'][1],viz_config['opendaylight-test-feature'])