"""
utility.py: defines miscellaneous utility services.
"""
from typing import Optional, Tuple

import netaddr

from core import utils
from core.errors import CoreCommandError
from core.executables import SYSCTL
from core.nodes.base import CoreNode
from core.services.coreservices import CoreService, ServiceMode


class UtilService(CoreService):
    """
    Parent class for utility services.
    """

    name: Optional[str] = None
    group: str = "Utility"

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        return ""


class IPForwardService(UtilService):
    name: str = "IPForward"
    configs: Tuple[str, ...] = ("ipforward.sh",)
    startup: Tuple[str, ...] = ("bash ipforward.sh",)

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        return cls.generateconfiglinux(node, filename)

    @classmethod
    def generateconfiglinux(cls, node: CoreNode, filename: str) -> str:
        cfg = """\
#!/bin/sh
# auto-generated by IPForward service (utility.py)
%(sysctl)s -w net.ipv4.conf.all.forwarding=1
%(sysctl)s -w net.ipv4.conf.default.forwarding=1
%(sysctl)s -w net.ipv6.conf.all.forwarding=1
%(sysctl)s -w net.ipv6.conf.default.forwarding=1
%(sysctl)s -w net.ipv4.conf.all.send_redirects=0
%(sysctl)s -w net.ipv4.conf.default.send_redirects=0
%(sysctl)s -w net.ipv4.conf.all.rp_filter=0
%(sysctl)s -w net.ipv4.conf.default.rp_filter=0
""" % {
            "sysctl": SYSCTL
        }
        for iface in node.get_ifaces():
            name = utils.sysctl_devname(iface.name)
            cfg += "%s -w net.ipv4.conf.%s.forwarding=1\n" % (SYSCTL, name)
            cfg += "%s -w net.ipv4.conf.%s.send_redirects=0\n" % (SYSCTL, name)
            cfg += "%s -w net.ipv4.conf.%s.rp_filter=0\n" % (SYSCTL, name)
        return cfg


class DefaultRouteService(UtilService):
    name: str = "DefaultRoute"
    configs: Tuple[str, ...] = ("defaultroute.sh",)
    startup: Tuple[str, ...] = ("bash defaultroute.sh",)

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        routes = []
        ifaces = node.get_ifaces()
        if ifaces:
            iface = ifaces[0]
            for ip in iface.ips():
                net = ip.cidr
                if net.size > 1:
                    router = net[1]
                    routes.append(str(router))
        cfg = "#!/bin/sh\n"
        cfg += "# auto-generated by DefaultRoute service (utility.py)\n"
        for route in routes:
            cfg += f"ip route add default via {route}\n"
        return cfg


class DefaultMulticastRouteService(UtilService):
    name: str = "DefaultMulticastRoute"
    configs: Tuple[str, ...] = ("defaultmroute.sh",)
    startup: Tuple[str, ...] = ("bash defaultmroute.sh",)

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        cfg = "#!/bin/sh\n"
        cfg += "# auto-generated by DefaultMulticastRoute service (utility.py)\n"
        cfg += "# the first interface is chosen below; please change it "
        cfg += "as needed\n"
        for iface in node.get_ifaces(control=False):
            rtcmd = "ip route add 224.0.0.0/4 dev"
            cfg += "%s %s\n" % (rtcmd, iface.name)
            cfg += "\n"
            break
        return cfg


class StaticRouteService(UtilService):
    name: str = "StaticRoute"
    configs: Tuple[str, ...] = ("staticroute.sh",)
    startup: Tuple[str, ...] = ("bash staticroute.sh",)
    custom_needed: bool = True

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        cfg = "#!/bin/sh\n"
        cfg += "# auto-generated by StaticRoute service (utility.py)\n#\n"
        cfg += "# NOTE: this service must be customized to be of any use\n"
        cfg += "#       Below are samples that you can uncomment and edit.\n#\n"
        for iface in node.get_ifaces(control=False):
            cfg += "\n".join(map(cls.routestr, iface.ips()))
            cfg += "\n"
        return cfg

    @staticmethod
    def routestr(ip: netaddr.IPNetwork) -> str:
        address = str(ip.ip)
        if netaddr.valid_ipv6(address):
            dst = "3ffe:4::/64"
        else:
            dst = "10.9.8.0/24"
        if ip[-2] == ip[1]:
            return ""
        else:
            rtcmd = "#/sbin/ip route add %s via" % dst
            return "%s %s" % (rtcmd, ip[1])


class SshService(UtilService):
    name: str = "SSH"
    configs: Tuple[str, ...] = ("startsshd.sh", "/etc/ssh/sshd_config")
    dirs: Tuple[str, ...] = ("/etc/ssh", "/var/run/sshd")
    startup: Tuple[str, ...] = ("bash startsshd.sh",)
    shutdown: Tuple[str, ...] = ("killall sshd",)
    validation_mode: ServiceMode = ServiceMode.BLOCKING

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        """
        Use a startup script for launching sshd in order to wait for host
        key generation.
        """
        sshcfgdir = cls.dirs[0]
        sshstatedir = cls.dirs[1]
        sshlibdir = "/usr/lib/openssh"
        if filename == "startsshd.sh":
            return """\
#!/bin/sh
# auto-generated by SSH service (utility.py)
ssh-keygen -q -t rsa -N "" -f %s/ssh_host_rsa_key
chmod 655 %s
# wait until RSA host key has been generated to launch sshd
/usr/sbin/sshd -f %s/sshd_config
""" % (
                sshcfgdir,
                sshstatedir,
                sshcfgdir,
            )
        else:
            return """\
# auto-generated by SSH service (utility.py)
Port 22
Protocol 2
HostKey %s/ssh_host_rsa_key
UsePrivilegeSeparation yes
PidFile %s/sshd.pid

KeyRegenerationInterval 3600
ServerKeyBits 768

SyslogFacility AUTH
LogLevel INFO

LoginGraceTime 120
PermitRootLogin yes
StrictModes yes

RSAAuthentication yes
PubkeyAuthentication yes

IgnoreRhosts yes
RhostsRSAAuthentication no
HostbasedAuthentication no

PermitEmptyPasswords no
ChallengeResponseAuthentication no

X11Forwarding yes
X11DisplayOffset 10
PrintMotd no
PrintLastLog yes
TCPKeepAlive yes

AcceptEnv LANG LC_*
Subsystem sftp %s/sftp-server
UsePAM yes
UseDNS no
""" % (
                sshcfgdir,
                sshstatedir,
                sshlibdir,
            )


class DhcpService(UtilService):
    name: str = "DHCP"
    configs: Tuple[str, ...] = ("/etc/dhcp/dhcpd.conf",)
    dirs: Tuple[str, ...] = ("/etc/dhcp", "/var/lib/dhcp")
    startup: Tuple[str, ...] = ("touch /var/lib/dhcp/dhcpd.leases", "dhcpd")
    shutdown: Tuple[str, ...] = ("killall dhcpd",)
    validate: Tuple[str, ...] = ("pidof dhcpd",)

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        """
        Generate a dhcpd config file using the network address of
        each interface.
        """
        cfg = """\
# auto-generated by DHCP service (utility.py)
# NOTE: move these option lines into the desired pool { } block(s) below
#option domain-name "test.com";
#option domain-name-servers 10.0.0.1;
#option routers 10.0.0.1;

log-facility local6;

default-lease-time 600;
max-lease-time 7200;

ddns-update-style none;
"""
        for iface in node.get_ifaces(control=False):
            cfg += "\n".join(map(cls.subnetentry, iface.ip4s))
            cfg += "\n"
        return cfg

    @staticmethod
    def subnetentry(ip: netaddr.IPNetwork) -> str:
        """
        Generate a subnet declaration block given an IPv4 prefix string
        for inclusion in the dhcpd3 config file.
        """
        if ip.size == 1:
            return ""
        # divide the address space in half
        index = (ip.size - 2) / 2
        rangelow = ip[index]
        rangehigh = ip[-2]
        return """
subnet %s netmask %s {
  pool {
    range %s %s;
    default-lease-time 600;
    option routers %s;
  }
}
""" % (
            ip.cidr.ip,
            ip.netmask,
            rangelow,
            rangehigh,
            ip.ip,
        )


class DhcpClientService(UtilService):
    """
    Use a DHCP client for all interfaces for addressing.
    """

    name: str = "DHCPClient"
    configs: Tuple[str, ...] = ("startdhcpclient.sh",)
    startup: Tuple[str, ...] = ("bash startdhcpclient.sh",)
    shutdown: Tuple[str, ...] = ("killall dhclient",)
    validate: Tuple[str, ...] = ("pidof dhclient",)

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        """
        Generate a script to invoke dhclient on all interfaces.
        """
        cfg = "#!/bin/sh\n"
        cfg += "# auto-generated by DHCPClient service (utility.py)\n"
        cfg += "# uncomment this mkdir line and symlink line to enable client-"
        cfg += "side DNS\n# resolution based on the DHCP server response.\n"
        cfg += "#mkdir -p /var/run/resolvconf/interface\n"
        for iface in node.get_ifaces(control=False):
            cfg += "#ln -s /var/run/resolvconf/interface/%s.dhclient" % iface.name
            cfg += " /var/run/resolvconf/resolv.conf\n"
            cfg += "/sbin/dhclient -nw -pf /var/run/dhclient-%s.pid" % iface.name
            cfg += " -lf /var/run/dhclient-%s.lease %s\n" % (iface.name, iface.name)
        return cfg


class FtpService(UtilService):
    """
    Start a vsftpd server.
    """

    name: str = "FTP"
    configs: Tuple[str, ...] = ("vsftpd.conf",)
    dirs: Tuple[str, ...] = ("/var/run/vsftpd/empty", "/var/ftp")
    startup: Tuple[str, ...] = ("vsftpd ./vsftpd.conf",)
    shutdown: Tuple[str, ...] = ("killall vsftpd",)
    validate: Tuple[str, ...] = ("pidof vsftpd",)

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        """
        Generate a vsftpd.conf configuration file.
        """
        return """\
# vsftpd.conf auto-generated by FTP service (utility.py)
listen=YES
anonymous_enable=YES
local_enable=YES
dirmessage_enable=YES
use_localtime=YES
xferlog_enable=YES
connect_from_port_20=YES
xferlog_file=/var/log/vsftpd.log
ftpd_banner=Welcome to the CORE FTP service
secure_chroot_dir=/var/run/vsftpd/empty
anon_root=/var/ftp
"""


class HttpService(UtilService):
    """
    Start an apache server.
    """

    name: str = "HTTP"
    configs: Tuple[str, ...] = (
        "/etc/apache2/apache2.conf",
        "/etc/apache2/envvars",
        "/var/www/index.html",
    )
    dirs: Tuple[str, ...] = (
        "/etc/apache2",
        "/var/run/apache2",
        "/var/log/apache2",
        "/run/lock",
        "/var/lock/apache2",
        "/var/www",
    )
    startup: Tuple[str, ...] = ("chown www-data /var/lock/apache2", "apache2ctl start")
    shutdown: Tuple[str, ...] = ("apache2ctl stop",)
    validate: Tuple[str, ...] = ("pidof apache2",)
    APACHEVER22: int = 22
    APACHEVER24: int = 24

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        """
        Generate an apache2.conf configuration file.
        """
        if filename == cls.configs[0]:
            return cls.generateapache2conf(node, filename)
        elif filename == cls.configs[1]:
            return cls.generateenvvars(node, filename)
        elif filename == cls.configs[2]:
            return cls.generatehtml(node, filename)
        else:
            return ""

    @classmethod
    def detectversionfromcmd(cls) -> int:
        """
        Detect the apache2 version using the 'a2query' command.
        """
        try:
            result = utils.cmd("a2query -v")
            status = 0
        except CoreCommandError as e:
            status = e.returncode
            result = e.stderr
        if status == 0 and result[:3] == "2.4":
            return cls.APACHEVER24
        return cls.APACHEVER22

    @classmethod
    def generateapache2conf(cls, node: CoreNode, filename: str) -> str:
        lockstr = {
            cls.APACHEVER22: "LockFile ${APACHE_LOCK_DIR}/accept.lock\n",
            cls.APACHEVER24: "Mutex file:${APACHE_LOCK_DIR} default\n",
        }
        mpmstr = {
            cls.APACHEVER22: "",
            cls.APACHEVER24: "LoadModule mpm_worker_module /usr/lib/apache2/modules/mod_mpm_worker.so\n",
        }
        permstr = {
            cls.APACHEVER22: "    Order allow,deny\n    Deny from all\n    Satisfy all\n",
            cls.APACHEVER24: "    Require all denied\n",
        }
        authstr = {
            cls.APACHEVER22: "LoadModule authz_default_module /usr/lib/apache2/modules/mod_authz_default.so\n",
            cls.APACHEVER24: "LoadModule authz_core_module /usr/lib/apache2/modules/mod_authz_core.so\n",
        }
        permstr2 = {
            cls.APACHEVER22: "\t\tOrder allow,deny\n\t\tallow from all\n",
            cls.APACHEVER24: "\t\tRequire all granted\n",
        }
        version = cls.detectversionfromcmd()
        cfg = "# apache2.conf generated by utility.py:HttpService\n"
        cfg += lockstr[version]
        cfg += """\
PidFile ${APACHE_PID_FILE}
Timeout 300
KeepAlive On
MaxKeepAliveRequests 100
KeepAliveTimeout 5
"""
        cfg += mpmstr[version]
        cfg += """\

<IfModule mpm_prefork_module>
    StartServers          5
    MinSpareServers       5
    MaxSpareServers      10
    MaxClients          150
    MaxRequestsPerChild   0
</IfModule>

<IfModule mpm_worker_module>
    StartServers          2
    MinSpareThreads      25
    MaxSpareThreads      75
    ThreadLimit          64
    ThreadsPerChild      25
    MaxClients          150
    MaxRequestsPerChild   0
</IfModule>

<IfModule mpm_event_module>
    StartServers          2
    MinSpareThreads      25
    MaxSpareThreads      75
    ThreadLimit          64
    ThreadsPerChild      25
    MaxClients          150
    MaxRequestsPerChild   0
</IfModule>

User ${APACHE_RUN_USER}
Group ${APACHE_RUN_GROUP}

AccessFileName .htaccess

<Files ~ "^\\.ht">
"""
        cfg += permstr[version]
        cfg += """\
</Files>

DefaultType None

HostnameLookups Off

ErrorLog ${APACHE_LOG_DIR}/error.log
LogLevel warn

#Include mods-enabled/*.load
#Include mods-enabled/*.conf
LoadModule alias_module /usr/lib/apache2/modules/mod_alias.so
LoadModule auth_basic_module /usr/lib/apache2/modules/mod_auth_basic.so
"""
        cfg += authstr[version]
        cfg += """\
LoadModule authz_host_module /usr/lib/apache2/modules/mod_authz_host.so
LoadModule authz_user_module /usr/lib/apache2/modules/mod_authz_user.so
LoadModule autoindex_module /usr/lib/apache2/modules/mod_autoindex.so
LoadModule dir_module /usr/lib/apache2/modules/mod_dir.so
LoadModule env_module /usr/lib/apache2/modules/mod_env.so

NameVirtualHost *:80
Listen 80

<IfModule mod_ssl.c>
    Listen 443
</IfModule>
<IfModule mod_gnutls.c>
    Listen 443
</IfModule>

LogFormat "%v:%p %h %l %u %t \\"%r\\" %>s %O \\"%{Referer}i\\" \\"%{User-Agent}i\\"" vhost_combined
LogFormat "%h %l %u %t \\"%r\\" %>s %O \\"%{Referer}i\\" \\"%{User-Agent}i\\"" combined
LogFormat "%h %l %u %t \\"%r\\" %>s %O" common
LogFormat "%{Referer}i -> %U" referer
LogFormat "%{User-agent}i" agent

ServerTokens OS
ServerSignature On
TraceEnable Off

<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www
    <Directory />
        Options FollowSymLinks
        AllowOverride None
    </Directory>
    <Directory /var/www/>
        Options Indexes FollowSymLinks MultiViews
        AllowOverride None
"""
        cfg += permstr2[version]
        cfg += """\
    </Directory>
    ErrorLog ${APACHE_LOG_DIR}/error.log
    LogLevel warn
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

"""
        return cfg

    @classmethod
    def generateenvvars(cls, node: CoreNode, filename: str) -> str:
        return """\
# this file is used by apache2ctl - generated by utility.py:HttpService
# these settings come from a default Ubuntu apache2 installation
export APACHE_RUN_USER=www-data
export APACHE_RUN_GROUP=www-data
export APACHE_PID_FILE=/var/run/apache2.pid
export APACHE_RUN_DIR=/var/run/apache2
export APACHE_LOCK_DIR=/var/lock/apache2
export APACHE_LOG_DIR=/var/log/apache2
export LANG=C
export LANG
"""

    @classmethod
    def generatehtml(cls, node: CoreNode, filename: str) -> str:
        body = (
            """\
<!-- generated by utility.py:HttpService -->
<h1>%s web server</h1>
<p>This is the default web page for this server.</p>
<p>The web server software is running but no content has been added, yet.</p>
"""
            % node.name
        )
        for iface in node.get_ifaces(control=False):
            body += "<li>%s - %s</li>\n" % (iface.name, [str(x) for x in iface.ips()])
        return "<html><body>%s</body></html>" % body


class PcapService(UtilService):
    """
    Pcap service for logging packets.
    """

    name: str = "pcap"
    configs: Tuple[str, ...] = ("pcap.sh",)
    startup: Tuple[str, ...] = ("bash pcap.sh start",)
    shutdown: Tuple[str, ...] = ("bash pcap.sh stop",)
    validate: Tuple[str, ...] = ("pidof tcpdump",)
    meta: str = "logs network traffic to pcap packet capture files"

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        """
        Generate a startpcap.sh traffic logging script.
        """
        cfg = """
#!/bin/sh
# set tcpdump options here (see 'man tcpdump' for help)
# (-s snap length, -C limit pcap file length, -n disable name resolution)
DUMPOPTS="-s 12288 -C 10 -n"

if [ "x$1" = "xstart" ]; then

"""
        for iface in node.get_ifaces():
            if iface.control:
                cfg += "# "
            redir = "< /dev/null"
            cfg += "tcpdump ${DUMPOPTS} -w %s.%s.pcap -i %s %s &\n" % (
                node.name,
                iface.name,
                iface.name,
                redir,
            )
        cfg += """

elif [ "x$1" = "xstop" ]; then
    mkdir -p ${SESSION_DIR}/pcap
    mv *.pcap ${SESSION_DIR}/pcap
fi;
"""
        return cfg


class RadvdService(UtilService):
    name: str = "radvd"
    configs: Tuple[str, ...] = ("/etc/radvd/radvd.conf",)
    dirs: Tuple[str, ...] = ("/etc/radvd", "/var/run/radvd")
    startup: Tuple[str, ...] = (
        "radvd -C /etc/radvd/radvd.conf -m logfile -l /var/log/radvd.log",
    )
    shutdown: Tuple[str, ...] = ("pkill radvd",)
    validate: Tuple[str, ...] = ("pidof radvd",)

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        """
        Generate a RADVD router advertisement daemon config file
        using the network address of each interface.
        """
        cfg = "# auto-generated by RADVD service (utility.py)\n"
        for iface in node.get_ifaces(control=False):
            prefixes = list(map(cls.subnetentry, iface.ips()))
            if len(prefixes) < 1:
                continue
            cfg += (
                """\
interface %s
{
        AdvSendAdvert on;
        MinRtrAdvInterval 3;
        MaxRtrAdvInterval 10;
        AdvDefaultPreference low;
        AdvHomeAgentFlag off;
"""
                % iface.name
            )
            for prefix in prefixes:
                if prefix == "":
                    continue
                cfg += (
                    """\
        prefix %s
        {
                AdvOnLink on;
                AdvAutonomous on;
                AdvRouterAddr on;
        };
"""
                    % prefix
                )
            cfg += "};\n"
        return cfg

    @staticmethod
    def subnetentry(ip: netaddr.IPNetwork) -> str:
        """
        Generate a subnet declaration block given an IPv6 prefix string
        for inclusion in the RADVD config file.
        """
        address = str(ip.ip)
        if netaddr.valid_ipv6(address):
            return str(ip)
        else:
            return ""


class AtdService(UtilService):
    """
    Atd service for scheduling at jobs
    """

    name: str = "atd"
    configs: Tuple[str, ...] = ("startatd.sh",)
    dirs: Tuple[str, ...] = ("/var/spool/cron/atjobs", "/var/spool/cron/atspool")
    startup: Tuple[str, ...] = ("bash startatd.sh",)
    shutdown: Tuple[str, ...] = ("pkill atd",)

    @classmethod
    def generate_config(cls, node: CoreNode, filename: str) -> str:
        return """
#!/bin/sh
echo 00001 > /var/spool/cron/atjobs/.SEQ
chown -R daemon /var/spool/cron/*
chmod -R 700 /var/spool/cron/*
atd
"""


class UserDefinedService(UtilService):
    """
    Dummy service allowing customization of anything.
    """

    name: str = "UserDefined"
    meta: str = "Customize this service to do anything upon startup."