"""
Predicates
and helper functions used to group interfaces together and generate the
necessary data for the dashboard templates.
"""
import re
import logging
import json
from itertools import product
from functools import reduce
from string import ascii_uppercase
from brian_dashboard_manager.templating.render import create_panel, \
    create_panel_target

PANEL_HEIGHT = 12
PANEL_WIDTH = 24

logger = logging.getLogger(__file__)


def get_description(interface):
    return interface.get('description', '').strip()


def is_physical_interface(interface):
    return re.match('^PHY', get_description(interface))


def is_aggregate_interface(interface):
    return re.match('^LAG', get_description(interface))


def is_logical_interface(interface):
    return re.match('^SRV_', get_description(interface))


def is_nren(interface):
    regex = '(PHY|LAG|(SRV_(GLOBAL|LHCONE|MDVPN|IAS|CLS|L3VPN))) CUSTOMER'
    return re.match(regex, get_description(interface))


def is_cls(interface):
    return 'SRV_CLS' in get_description(interface)


def is_cls_peer(interface):
    return 'SRV_CLS PRIVATE' in get_description(interface)


def is_ias_public(interface):
    return 'SRV_IAS PUBLIC' in get_description(interface)


def is_ias_private(interface):
    return 'SRV_IAS PRIVATE' in get_description(interface)


def is_ias_customer(interface):
    return 'SRV_IAS CUSTOMER' in get_description(interface)


def is_ias_upstream(interface):
    return 'SRV_IAS UPSTREAM' in get_description(interface)


def is_ias_peer(interface):
    return is_ias_public(interface) or is_ias_private(interface)


def is_re_peer(interface):
    return 'SRV_GLOBAL RE_INTERCONNECT' in get_description(interface)


def is_re_customer(interface):
    regex = '(PHY|LAG|SRV_GLOBAL) CUSTOMER'
    return re.match(regex, get_description(interface))


def is_gcs(interface):
    return re.match('^SRV_GCS', get_description(interface))


def is_geantopen(interface):
    return 'GEANTOPEN' in get_description(interface)


def is_l2circuit(interface):
    return 'SRV_L2CIRCUIT' in get_description(interface)


def is_lhcone_peer(interface):
    description = get_description(interface)
    return 'LHCONE' in description and 'SRV_L3VPN RE' in description


def is_lhcone_customer(interface):
    description = get_description(interface)
    return 'LHCONE' in description and 'SRV_L3VPN CUSTOMER' in description


def is_lhcone(interface):
    regex = 'SRV_L3VPN (CUSTOMER|RE_INTERCONNECT)'
    return re.match(regex, get_description(interface))


def is_mdvpn(interface):
    return re.match('^SRV_MDVPN CUSTOMER', get_description(interface))


def is_infrastructure_backbone(interface):
    regex = '(SRV_GLOBAL|LAG|PHY) INFRASTRUCTURE BACKBONE'
    return re.match(regex, get_description(interface))


def is_lag_backbone(interface):
    is_lag = 'LAG' in get_description(interface)
    return is_infrastructure_backbone(interface) and is_lag


def is_cae1(interface):
    iface_regex = r'^ae12(\.\d+|$)$'
    is_router = interface.get('router', '').lower() == 'mx1.lon.uk.geant.net'
    is_iface = re.match(iface_regex, interface.get('name'))
    return is_router and is_iface


def parse_backbone_name(description, *args, **kwargs):
    link = description.split('|')[1].strip()
    link = link.replace('( ', '(')
    return link


def is_phy_upstream(interface):
    return re.match('^PHY UPSTREAM', get_description(interface))


def parse_phy_upstream_name(description, host):
    name = description.split(' ')[2].strip().upper()
    location = host.split('.')[1].upper()
    return f'{name} - {location}'


def num_generator(start=1):
    num = start
    while True:
        yield num
        num += 1


def gridPos_generator(id_generator, start=0, agg=False):
    num = start
    while True:
        yield {
            "height": PANEL_HEIGHT,
            "width": PANEL_WIDTH if not agg else PANEL_WIDTH // 2,
            "x": 0,
            "y": num * PANEL_HEIGHT,
            "id": next(id_generator)
        }
        if agg:
            yield {
                "height": PANEL_HEIGHT,
                "width": PANEL_WIDTH // 2,
                "x": PANEL_WIDTH // 2,
                "y": num * PANEL_HEIGHT,
                "id": next(id_generator)
            }
        num += 1


def letter_generator():
    i = 0
    j = 0
    num_letters = len(ascii_uppercase)
    while True:
        result = ascii_uppercase[i % num_letters]

        # tack on an extra letter if we are out of them
        if (i >= num_letters):
            result += ascii_uppercase[j % num_letters]
            j += 1
            if (j != 0 and j % num_letters == 0):
                i += 1
        else:
            i += 1

        yield result


# peer_predicate is a function that is used to filter the interfaces
# parse_func receives interface information and returns a peer name.
def get_interface_data(interfaces, name_parse_func=None):
    result = {}

    if not name_parse_func:
        # Most (but not all) descriptions use a format
        # which has the peer name as the third element.
        def name_parse_func(desc, *args, **kwargs):
            return desc.split(' ')[2].upper()

    for interface in interfaces:

        description = interface.get('description', '').strip()
        interface_name = interface.get('name')
        host = interface.get('router', '')

        dashboard_name = name_parse_func(description, host)

        peer = result.get(dashboard_name, [])

        router = host.replace('.geant.net', '')
        panel_title = f"{router} - {{}} - {interface_name} - {description}"

        peer.append({
            'title': panel_title,
            'interface': interface_name,
            'hostname': host,
            'has_v6': len(interface.get('ipv6', [])) > 0
        })
        result[dashboard_name] = peer
    return result


def get_aggregate_interface_data(interfaces, agg_type):
    result = []

    def reduce_func(prev, curr):
        remotes = prev.get(curr['remote'], [])
        remotes.append(curr)
        all_agg = prev.get('EVERYSINGLEPANEL', [])
        all_agg.append(curr)
        prev[curr['remote']] = remotes
        prev['EVERYSINGLEPANEL'] = all_agg
        return prev

    for interface in interfaces:

        description = interface.get('description', '').strip()
        interface_name = interface.get('name')
        host = interface.get('router', '')

        remote = description.split(' ')[2].upper()

        result.append({
            'type': agg_type,
            'interface': interface_name,
            'hostname': host,
            'remote': remote,
            'alias': f"{host.split('.')[1].upper()} - {remote}",
        })
    return reduce(reduce_func, result, {})


# Helper used for generating stacked aggregate panels
# with multiple target fields (ingress/egress)
def get_aggregate_targets(targets):
    ingress = []
    egress = []

    # used to generate refIds
    letters = letter_generator()

    for target in targets:
        ref_id = next(letters)
        in_data = {
            **target,
            'alias': f"{target['alias']} - Ingress Traffic",
            'refId': ref_id,
            'select_field': 'ingress'
        }
        out_data = {
            **target,
            'alias': f"{target['alias']} - Egress Traffic",
            'refId': ref_id,
            'select_field': 'egress'
        }
        ingress_target = create_panel_target(in_data)
        egress_target = create_panel_target(out_data)
        ingress.append(ingress_target)
        egress.append(egress_target)

    return ingress, egress


# Helper used for generating all traffic/error panels
# with a single target field (ingress/egress or err/s)
def get_panel_fields(panel, panel_type, datasource):
    letters = letter_generator()

    def get_target_data(alias, field):
        return {
            **panel,  # panel has target hostname and interface
            'alias': alias,
            'refId': next(letters),
            'select_field': field,
            'percentile': 'percentile' in alias.lower(),
        }

    error_fields = [('Ingress Errors', 'errorsIn'),
                    ('Egress Errors', 'errorsOut')]

    ingress = ['Ingress Traffic', 'Ingress 95th Percentile']
    egress = ['Egress Traffic', 'Egress 95th Percentile']

    is_v6 = panel_type == 'IPv6'
    is_multicast = panel_type == 'multicast'
    is_error = panel_type == 'errors'
    in_field = 'ingressv6' if is_v6 else \
        'ingressMulticast' if is_multicast else 'ingress'

    out_field = 'egressv6' if is_v6 else \
        'egressMulticast' if is_multicast else 'egress'

    if is_multicast:
        def add_multicast(label):
            return 'Multicast ' + label
        ingress = list(map(add_multicast, ingress))
        egress = list(map(add_multicast, egress))

    fields = [*product(ingress, [in_field]), *product(egress, [out_field])]

    targets = error_fields if is_error else fields

    return create_panel({
        **panel,
        'datasource': datasource,
        'linewidth': 1,
        'title': panel['title'].format(panel_type),
        'panel_targets': [get_target_data(*target) for target in targets],
        'y_axis_type': 'errors' if is_error else 'bits',
    })


def get_dashboard_data(data, datasource, tag, errors=False):
    id_gen = num_generator()
    gridPos = gridPos_generator(id_gen)

    def get_panel_definitions(panels, datasource):
        result = []
        for panel in panels:
            result.append(get_panel_fields(
                {**panel, **next(gridPos)}, 'traffic', datasource))
            if panel.get('has_v6', False):
                result.append(get_panel_fields(
                    {**panel, **next(gridPos)}, 'IPv6', datasource))
            # result.append(get_panel_fields(
            #     {**panel, **next(gridPos)}, 'multicast', datasource))
            if errors:
                result.append(get_panel_fields(
                    {**panel, **next(gridPos)}, 'errors', datasource))
        return result

    for peer, panels in data.items():
        result = {
            'title': peer,
            'datasource': datasource,
            'panels': get_panel_definitions(panels, datasource),
        }

        if isinstance(tag, list):
            result['tags'] = tag
        else:
            result['tag'] = tag

        yield result


def create_aggregate_panel(title, gridpos, targets, datasource):

    ingress_targets, egress_targets = get_aggregate_targets(targets)
    result = []

    ingress_pos = next(gridpos)
    egress_pos = next(gridpos)

    is_total = 'totals' in title.lower()

    def reduce_alias(prev, curr):
        d = json.loads(curr)
        alias = d['alias']
        if 'egress' in alias.lower():
            prev[alias] = '#0000FF'
        else:
            prev[alias] = '#00FF00'
        return prev

    ingress_colors = reduce(reduce_alias, ingress_targets, {})
    egress_colors = reduce(reduce_alias, egress_targets, {})

    result.append(create_panel({
        **ingress_pos,
        'stack': True,
        'linewidth': 0 if is_total else 1,
        'datasource': datasource,
        'title': title + ' - ingress',
        'targets': ingress_targets,
        'y_axis_type': 'bits',
        'alias_colors': json.dumps(ingress_colors) if is_total else {}
    }))

    result.append(create_panel({
        **egress_pos,
        'stack': True,
        'linewidth': 0 if is_total else 1,
        'datasource': datasource,
        'title': title + ' - egress',
        'targets': egress_targets,
        'y_axis_type': 'bits',
        'alias_colors': json.dumps(egress_colors) if is_total else {}
    }))

    return result


def get_aggregate_dashboard_data(title, targets, datasource, tag):
    id_gen = num_generator()
    gridPos = gridPos_generator(id_gen, agg=True)

    panels = []
    all_targets = targets.get('EVERYSINGLEPANEL', [])

    ingress, egress = create_aggregate_panel(
        title, gridPos, all_targets, datasource)
    panels.extend([ingress, egress])

    totals_title = title + ' - Totals'
    t_in, t_eg = create_aggregate_panel(
        totals_title, gridPos, all_targets, datasource)
    panels.extend([t_in, t_eg])

    if 'EVERYSINGLEPANEL' in targets:
        del targets['EVERYSINGLEPANEL']

    for target in targets:
        _in, _out = create_aggregate_panel(
            title + f' - {target}', gridPos, targets[target], datasource)
        panels.extend([_in, _out])

    result = {
        'title': title,
        'datasource': datasource,
        'panels': panels,

    }
    if isinstance(tag, list):
        result['tags'] = tag
    else:
        result['tag'] = tag

    return result