import json
import ipaddress

from copy import deepcopy
from cfg_checker.modules.network.network_errors import NetworkErrors

_network_item = {
    "runtime": {},
    "config": {},
    "reclass": {}
}
errors = NetworkErrors()
_console = []


def cprint(_str):
    print(_str)
    _console.append(_str)


# adding net data to tree
def _add_data(_list, _n, _h, _d):
    if _n not in _list:
        _list[_n] = {}
        _list[_n][_h] = [_d]
    elif _h not in _list[_n]:
        # there is no such host, just create it
        _list[_n][_h] = [_d]
    else:
        # there is such host... this is an error
        errors.add_error(
            errors.NET_DUPLICATE_IF,
            host=_h,
            dup_if=_d['name']
        )
        _list[_n][_h].append(_d)


def _map_network_for_host(host, if_class, net_list, data):
    # filter networks for this IF IP
    _nets = [n for n in net_list.keys() if if_class.ip in n]
    _masks = [n.netmask for n in _nets]
    if len(_nets) > 1:
        # There a multiple network found for this IP, Error
        errors.add_error(
            errors.NET_SUBNET_INTERSECT,
            host=host,
            ip=str(if_class.exploded),
            networks="; ".join([str(_n) for _n in _nets])
        )
    # check mask match
    if len(_nets) > 0 and if_class.netmask not in _masks:
        errors.add_error(
            errors.NET_MASK_MISMATCH,
            host=host,
            if_name=data['name'],
            if_cidr=if_class.exploded,
            if_mapped_networks=", ".join([str(_n) for _n in _nets])
        )

    if len(_nets) < 1:
        _add_data(net_list, if_class.network, host, data)
    else:
        # add all data
        for net in _nets:
            _add_data(net_list, net, host, data)

    return net_list


host = "tmp-node-00000"
node_data = {}
interfaces = {
    host: {}
}
_runtime = {}

with open("ifs_data.json", "rt") as ff:
    jj = json.loads(ff.read())

node_data['routes'] = jj.pop("routes")
node_data['networks'] = jj

cprint("# {} Networks".format(len(jj)))

for net_name, net_data in node_data['networks'].items():
    # cut net name
    _i = net_name.find('@')
    _name = net_name if _i < 0 else net_name[:_i]
    # get ips and calculate subnets
    if _name in ['lo']:
        # skip the localhost
        continue
    else:
        # add collected data to interface storage
        if _name not in interfaces[host]:
            interfaces[host][_name] = \
                deepcopy(_network_item)
        interfaces[host][_name]['runtime'] = \
            deepcopy(net_data)

    #  get data and make sure that wide mask goes first
    _ip4s = sorted(
        net_data['ipv4'],
        key=lambda s: s[s.index('/'):]
    )
    for _ip_str in _ip4s:
        # create interface class
        _if = ipaddress.IPv4Interface(_ip_str)
        # check if this is a VIP
        # ...all those will have /32 mask
        net_data['vip'] = None
        if _if.network.prefixlen == 32:
            net_data['vip'] = str(_if.exploded)
        if 'name' not in net_data:
            net_data['name'] = _name
        if 'ifs' not in net_data:
            net_data['ifs'] = [_if]
            # map it
            _runtime = _map_network_for_host(
                host,
                _if,
                _runtime,
                net_data
            )
        else:
            # data is already there, just add VIP
            net_data['ifs'].append(_if)


def process_interface(lvl, interface, tree, res):
    if abs(lvl) > 50:
        cprint("### ERROR: Probable cyclic dependency, exiting")
        return
    cprint("{}{}:{}".format(" "*(10+lvl), lvl, interface))
    # get childs for each root
    # tree row item (<if_name>, [<parents>], [<childs>])
    if lvl not in tree:
        # - no level - add it
        tree[lvl] = {}
    # there is such interface in this level?
    if interface not in tree[lvl]:
        # - IF not present
        _n = ''
        if interface not in res:
            _n = 'unknown IF'
            _p = None
            _c = None
        else:
            # -- get parents, add
            _p = res[interface]['lower']
            # -- get childs, add
            _c = res[interface]['upper']

        # if None, put empty list
        _p = _p if _p else []
        # if None, put empty list
        _c = _c if _c else []
        tree[lvl].update({
            interface: {
                "note": _n,
                "parents": _p,
                "children": _c,
                "size": len(_p) if len(_p) > len(_c) else len(_c)
            }
        })
        for p_if in tree[lvl][interface]["parents"]:
            # -- cycle: execute process for next parent, lvl-1
            process_interface(lvl-1, p_if, tree, res)
        for c_if in tree[lvl][interface]["children"]:
            # -- cycle: execute process for next child, lvl+1
            process_interface(lvl+1, c_if, tree, res)
    else:
        # - IF present - exit (been here already)
        cprint("{}{}".format(" "*(10+lvl), "--branch-end--\n"))
        return


def _put(cNet, cIndex, _list):
    _added = False
    _actual_index = -1
    # Check list len
    _len = len(_list)
    if cIndex >= _len:
        # grow list to meet index
        _list = _list + [''] * (cIndex - _len + 1)
        _len = len(_list)

    for _cI in range(cIndex, _len):
        # add child per index
        # if space is free
        if not _list[_cI]:
            _list[_cI] = cNet
            _added = True
            _actual_index = _cI
            break
    if not _added:
        # grow list by one entry
        _list = _list + [cNet]
        _actual_index = len(_list) - 1
    return _actual_index, _list


# build network hierachy
nr = node_data['networks']
# walk interface tree
for _ifname in node_data['networks']:
    _tree = {}
    _level = 0
    cprint("# -> {}".format(_ifname))
    process_interface(_level, _ifname, _tree, nr)
    # save tree for node/if
    node_data['networks'][_ifname]['tree'] = _tree

    # debug, print built tree
    cprint("# end '{}'".format(_ifname))
    lvls = list(_tree.keys())
    lvls.sort()
    n = len(lvls)
    m = max([len(_tree[k].keys()) for k in _tree.keys()])
    matrix = [["" for i in range(m)] for j in range(n)]
    x = 0
    while True:
        _lv = lvls.pop(0)
        # get all interfaces on this level
        nets = iter(_tree[_lv].keys())
        while True:
            y = 0
            # get next interface
            try:
                _net = next(nets)
            except StopIteration:
                break
            # all nets
            _a = [_net]
            # put current interface if this is only one left
            if not _tree[_lv][_net]['children']:
                if _net not in matrix[x]:
                    _, matrix[x] = _put(
                        _net,
                        y,
                        matrix[x]
                    )
                y += 1
            else:
                # get all nets with same child
                for _c in _tree[_lv][_net]['children']:
                    for _o_net in nets:
                        if _c in _tree[_lv][_o_net]['children']:
                            _a.append(_o_net)
                    # flush collected nets
                    for idx in range(len(_a)):
                        if _a[idx] in matrix[x]:
                            # there is such interface on this level
                            # get index
                            _nI = matrix[x].index(_a[idx])
                            _, matrix[x+1] = _put(
                                _c,
                                _nI,
                                matrix[x+1]
                            )
                        else:
                            # there is no such interface
                            # add it
                            _t, matrix[x] = _put(
                                _a[idx],
                                0,
                                matrix[x]
                            )
                            # also, put child
                            _, matrix[x+1] = _put(
                                _c,
                                _t,
                                matrix[x+1]
                            )
                        # remove collected nets from processing
                        if _a[idx] in nets:
                            nets.remove(_a[idx])
                    y += len(_a)
            if not nets:
                x += 1
                break
        if not lvls:
            break

    lines = []
    _columns = [len(max([i for i in li])) for li in matrix]
    for idx_y in range(m):
        line = ""
        for idx_x in range(n):
            _len = _columns[idx_x] if _columns[idx_x] else 1
            _fmt = "{" + ":{}".format(_len) + "} "
            line += _fmt.format(matrix[idx_x][idx_y])
        lines.append(line)
    node_data['networks'][_ifname]['matrix'] = matrix
    node_data['networks'][_ifname]['lines'] = lines
    cprint("#### Tree")
    cprint("\n".join(lines))

with open("debug_net_console.log", "w+") as ff:
    ff.write("\n".join(_console))