import json
import re
import subprocess
import sys


def shell(command):
    _ps = subprocess.Popen(
        command.split(),
        stdout=subprocess.PIPE
    ).communicate()[0].decode()

    return _ps


def cut_option(_param, _options_list, _option="n/a"):
    _result_list = []
    if _param in _options_list:
        _index = _options_list.index(_param)
        _option = _options_list[_index+1]
        _l1 = _options_list[:_index]
        _l2 = _options_list[_index+2:]
        _result_list = _l1 + _l2
    else:
        _result_list = _options_list
    return _option, _result_list


def get_linked_devices(if_name):
    if '@' in if_name:
        _name = if_name[:if_name.index('@')]
    else:
        _name = if_name
    # identify device type
    _dev_link_path = shell('readlink /sys/class/net/{}'.format(_name))
    _type = "unknown"
    if len(_dev_link_path) > 0:
        _tmp = _dev_link_path.split('/')
        _tmp = _tmp[_tmp.index("devices") + 1]
        if _tmp.startswith("pci"):
            _type = "physical"
        elif _tmp.startswith("virtual"):
            _type = "virtual"

    # get linked devices if any
    _links = shell(
        "find /sys/class/net/{}/ -type l".format(_name)
    )
    # there can be only one parent device
    _lower = None
    # can be more than one child device
    _upper = None
    for line in _links.splitlines():
        _line = line.rsplit('/', 1)[1]
        if _line.startswith("upper_"):
            if not _upper:
                _upper = []
            _upper.append(_line[6:])
        elif _line.startswith("lower_"):
            if not _lower:
                _lower = []
            _lower.append(_line[6:])

    return _lower, _upper, _type


def get_ifs_data():
    # Collect interface and IPs data
    # Compile regexps for detecting IPs
    if_start = re.compile(r"^[0-9]+: .*: \<.*\> .*$")
    if_link = re.compile(r"^\s{4}link\/ether\ .*$")
    if_ipv4 = re.compile(r"^\s{4}inet\ .*$")
    # variable prototypes
    _ifs = {}
    _name = None
    # get the "ip a" output
    _ifs_raw = shell('ip a')
    for line in _ifs_raw.splitlines():
        _if_data = {}
        if if_start.match(line):
            _tmp = line.split(':')
            _name = _tmp[1].strip()
            _name = _name.split('@') if '@' in _name else [_name, ""]
            _at = _name[1]
            _name = _name[0]
            _if_options = _tmp[2].strip().split(' ')
            _lower, _upper, _type = get_linked_devices(_name)
            _if_data['if_index'] = _tmp[0]
            _if_data['at'] = _at
            _if_data['mtu'], _if_options = cut_option("mtu", _if_options)
            _if_data['qlen'], _if_options = cut_option("qlen", _if_options)
            _if_data['state'], _if_options = cut_option("state", _if_options)
            _if_data['other'] = _if_options
            _if_data['ipv4'] = {}
            _if_data['link'] = {}
            _if_data['type'] = _type
            _if_data['upper'] = _upper
            _if_data['lower'] = _lower
            _ifs[_name] = _if_data
        elif if_link.match(line):
            if _name is None:
                continue
            else:
                _tmp = line.strip().split(' ', 2)
                _mac_addr = _tmp[1]
                _options = _tmp[2].split(' ')
                _brd, _options = cut_option("brd", _options)
                _netnsid, _options = cut_option("link-netnsid", _options)
                _ifs[_name]['link'][_mac_addr] = {}
                _ifs[_name]['link'][_mac_addr]['brd'] = _brd
                _ifs[_name]['link'][_mac_addr]['link-netnsid'] = _netnsid
                _ifs[_name]['link'][_mac_addr]['other'] = _options
        elif if_ipv4.match(line):
            if _name is None:
                continue
            else:
                _tmp = line.strip().split(' ', 2)
                _ip = _tmp[1]
                _options = _tmp[2].split(' ')
                _brd, _options = cut_option("brd", _options)
                # TODO: Parse other options, mask, brd, etc...
                _ifs[_name]['ipv4'][_ip] = {}
                _ifs[_name]['ipv4'][_ip]['brd'] = _brd
                _ifs[_name]['ipv4'][_ip]['other'] = _options

    # Collect routes data and try to match it with network
    # Compile regexp for detecting default route
    _routes = {
        'raw': []
    }
    _ip_route_raw = shell("ip -4 r")
    for line in _ip_route_raw.splitlines():
        _o = line.strip().split(' ')
        if line.startswith("default"):
            # default gateway found, prepare options and cut word 'default'
            _gate, _o = cut_option('via', _o, _option="0.0.0.0")
            _dev, _o = cut_option('dev', _o)
            _routes[_o[0]] = {
                'gateway': _gate,
                'device': _dev,
                'args': " ".join(_o[1:])
            }
        else:
            # network specific gateway found
            _gate, _o = cut_option('via', _o, _option=None)
            _dev, _o = cut_option('dev', _o)
            _src, _o = cut_option('src', _o)
            _routes[_o[0]] = {
                'gateway': _gate,
                'device': _dev,
                'source': _src,
                'args': " ".join(_o[1:])
            }

    _ifs["routes"] = _routes
    return _ifs


ifs_data = get_ifs_data()

if len(sys.argv) > 1 and sys.argv[1] == 'json':
    sys.stdout.write(json.dumps(ifs_data))
else:
    _ifs = sorted(ifs_data.keys())
    _ifs.remove("lo")
    _ifs.remove("routes")
    for _idx in range(len(_ifs)):
        _linked = ""
        if ifs_data[_ifs[_idx]]['lower']:
            _linked += "lower:{} ".format(
                ','.join(ifs_data[_ifs[_idx]]['lower'])
            )
        if ifs_data[_ifs[_idx]]['upper']:
            _linked += "upper:{} ".format(
                ','.join(ifs_data[_ifs[_idx]]['upper'])
            )
        _linked = _linked.strip()
        print("{0:8} {1:30} {2:18} {3:19} {4:5} {5:4} {6}".format(
            ifs_data[_ifs[_idx]]['type'],
            _ifs[_idx],
            ",".join(ifs_data[_ifs[_idx]]['link'].keys()),
            ",".join(ifs_data[_ifs[_idx]]['ipv4'].keys()),
            ifs_data[_ifs[_idx]]['mtu'],
            ifs_data[_ifs[_idx]]['state'],
            _linked
        ))

    print("\n")
    # default route
    print("default via {} on {} ({})".format(
        ifs_data["routes"]["default"]["gateway"],
        ifs_data["routes"]["default"]["device"],
        ifs_data["routes"]["default"]["args"]
    ))
    # detected routes
    _routes = ifs_data["routes"].keys()
    _routes.remove("raw")
    _routes.remove("default")
    _rt = ifs_data["routes"]
    for idx in range(0, len(_routes)):
        if _rt[_routes[idx]]["gateway"]:
            print("{0:18} <- {1:16} -> {2:18} on {3:30} ({4})".format(
                _routes[idx],
                _rt[_routes[idx]]["gateway"],
                _rt[_routes[idx]]["source"],
                _rt[_routes[idx]]["device"],
                _rt[_routes[idx]]["args"]
            ))
        else:
            print("{0:18} <- -> {1:18} on {2:30} ({3})".format(
                _routes[idx],
                _rt[_routes[idx]]["source"],
                _rt[_routes[idx]]["device"],
                _rt[_routes[idx]]["args"]
            ))