import os
import socket
import threading
from glob import glob
from configparser import ConfigParser
from netifaces import interfaces, ifaddresses, gateways, AF_INET, AF_LINK


ifname_mapping = {
   'eth0': 'enp1s0',
   'eth1': 'enp2s0',
   'eth2': 'enp3s0',
   'eth3': 'enp4s0',
}


if os.geteuid():
    def sudo(cmd):
        os.system(f'sudo {cmd}')
else:
    def sudo(cmd):
        os.system(cmd)


def get_config(section=None):
    """get content of box configuration

    :param section: if not None, return only given section
    :return: configuration as dict
    """
    parser = ConfigParser()
    cfgfiles = glob('/home/l_samenv/boxtools/cfg/%s_*.cfg' % socket.gethostname())
    if len(cfgfiles) != 1:
        raise ValueError('there must be one and only one single cfgfile %r' % cfgfiles)
    parser.read(cfgfiles[0])
    try:
        result = {k: dict(parser[k]) for k in ([section] if section else parser.sections())}
    except KeyError:
        return {}
    network = result.get('NETWORK', {})
    for name in list(network):
        network[ifname_mapping.get(name, name)] = network.pop(name)
    if section:
        return result[section]
    return result


def gethostthread(ip, event, result):
    try:
        result[0] = socket.gethostbyaddr(ip)[0]
    except Exception as e:
        pass
    event.set()


class MainIf:
    address = None
    ip = None
    gateway = None
    hostname = None
    carrier = True
    prev_ip = None

    def __init__(self):
        netcfg = get_config('NETWORK')
        for name, key in netcfg.items():
            if key.startswith(('dhcp', 'wan')):
                self.name = name
            break
        else:
            # take first one (alphabetically)
            self.name = sorted(netcfg)[0]
        self.hostnameresult = [None]
        with open(f'/sys/class/net/{self.name}/carrier_changes') as f:
            self.carrier_changes = f.read()
        self.poll()

    def hostname(self):
        return self.hostnameresult[0]

    def poll(self):
        with open(f'/sys/class/net/{self.name}/carrier') as f:
            carrier = f.read().startswith('1')
        with open(f'/sys/class/net/{self.name}/carrier_changes') as f:
            carrier_changes = f.read()
        if carrier_changes != self.carrier_changes:
            self.hostnameresult = [None]  # new instance for result
            self.carrier_changes = carrier_changes
            if carrier:
                sudo(f'dhclient -r {self.name}')
                sudo(f'dhclient {self.name}')
        self.carrier = carrier
        addrinfo = ifaddresses(self.name)
        self.address = addrinfo.get(AF_LINK, [{}])[0].get('addr')
        if carrier:
            self.ip = addrinfo.get(AF_INET, [{}])[0].get('addr')
            self.gateway = [g for g, n, _ in gateways().get(AF_INET, ()) if n == self.name]
        else:
            self.ip = None
            self.gateway = ()
        if self.carrier and self.ip and self.gateway:
            if self.ip != self.prev_ip:
                self.prev_ip = self.ip
                self.event = event = threading.Event()
                self.hostnameresult = list(self.hostnameresult)  # new instance for result
                threading.Thread(target=gethostthread,
                                 args=(self.ip, event, self.hostnameresult), daemon=True).start()
                event.wait(0.1)
                # in case of timeout, the thread may change self.hostnameresult later,
                # but only until carrier or ip changes
        else:
            self.prev_ip = None
        return self.carrier, self.ip, self.hostnameresult[0], self.gateway