#!/usr/bin/env python3

import argparse
import json
import logging
import logging.handlers
import os
import re
import sys
import warnings
##
import dns.exception
import dns.resolver
import requests
##
from lxml import etree
try:
    # https://www.freedesktop.org/software/systemd/python-systemd/journal.html#journalhandler-class
    from systemd import journal
    _has_journald = True
except ImportError:
    _has_journald = False


logfile = '~/.cache/ddns.log'

# Prep the log file.
logfile = os.path.abspath(os.path.expanduser(logfile))
os.makedirs(os.path.dirname(logfile), exist_ok = True, mode = 0o0700)
if not os.path.isfile(logfile):
    with open(logfile, 'w') as fh:
        fh.write('')
os.chmod(logfile, 0o0600)

# And set up logging.
_cfg_args = {'handlers': [],
             'level': logging.DEBUG}
if _has_journald:
    # There were some weird changes somewhere along the line.
    try:
        # But it's *probably* this one.
        h = journal.JournalHandler()
    except AttributeError:
        h = journal.JournaldLogHandler()
    # Systemd includes times, so we don't need to.
    h.setFormatter(logging.Formatter(style = '{',
                                     fmt = ('{name}:{levelname}:{name}:{filename}:'
                                            '{funcName}:{lineno}: {message}')))
    _cfg_args['handlers'].append(h)
h = logging.handlers.RotatingFileHandler(logfile,
                                         encoding = 'utf8',
                                         # Disable rotating for now.
                                         # maxBytes = 50000000000,
                                         # backupCount = 30
                                         )
h.setFormatter(logging.Formatter(style = '{',
                                 fmt = ('{asctime}:'
                                        '{levelname}:{name}:{filename}:'
                                        '{funcName}:{lineno}: {message}')))
_cfg_args['handlers'].append(h)
logging.basicConfig(**_cfg_args)
logger = logging.getLogger('DDNS')
logger.info('Logging initialized.')

is_tty = sys.stdin.isatty()
if not is_tty:
    logger.debug('Not running in an interactive invocation; disabling printing warnings')
else:
    logger.debug('Running in an interactive invocation; enabling printing warnings')


class Updater(object):
    tree = None
    records = {}
    api_base = None
    session = None
    token = None
    my_ips = {4: None, 6: None}
    resolver = dns.resolver.Resolver(configure = False)
    resolver.nameservers = ['64.6.64.6', '64.6.65.6']

    def __init__(self, cfg_path = '~/.config/ddns.xml', *args, **kwargs):
        self.xml = os.path.abspath(os.path.expanduser(cfg_path))
        logger.debug('Updater initialized with config {0}'.format(self.xml))
        self._getConf()
        self._getMyIP()
        self._getSession()

    def _getConf(self):
        try:
            with open(self.xml, 'rb') as fh:
                self.xml = etree.fromstring(fh.read())
        except FileNotFoundError as e:
            logger.error('Configuration file does not exist; please create it')
            raise e
        self.tree = self.xml.getroottree()
        self.token = self.xml.attrib['token']
        self.api_base = re.sub(r'/$', '', self.xml.attrib['base'])
        dom_xml = self.xml.findall('domain')
        num_doms = len(dom_xml)
        logger.debug('Found {0} domains in config'.format(num_doms))
        for idx, d in enumerate(dom_xml):
            domain = d.attrib['name']
            logger.debug('Iterating domain {0} ({1}/{2})'.format(domain, (idx + 1), num_doms))
            if domain not in self.records.keys():
                self.records[domain] = []
            sub_xml = d.findall('sub')
            num_subs = len(sub_xml)
            logger.debug('Found {0} records for domain {1}'.format(num_subs, domain))
            for idx2, s in enumerate(sub_xml):
                logger.debug('Adding record {0}.{1} to index ({2}/{3})'.format(s.text, domain, (idx2 + 1), num_subs))
                self.records[domain].append(s.text)
        return()

    def _getDNS(self, record):
        records = {}
        for t in ('A', 'AAAA'):
            logger.debug('Resolving {0} ({1})'.format(record, t))
            try:
                q = self.resolver.query(record, t)
                for a in q:
                    if t not in records.keys():
                        records[t] = []
                    ip = a.to_text()
                    logger.debug('Found IP {0} for record {1} ({2})'.format(ip, record, t))
                    records[t].append(ip)
            except dns.exception.Timeout as e:
                logger.error('Got a timeout when resolving {0} ({1}): {2}'.format(record, t, e))
                continue
            except dns.resolver.NXDOMAIN as e:
                # This is a debug instead of an error because that record type may not exist.
                logger.debug('Record {0} ({1}) does not exist: {2}'.format(record, t, e))
                continue
            except dns.resolver.YXDOMAIN as e:
                logger.error('Record {0} ({1}) is too long: {2}'.format(record, t, e))
                continue
            except dns.resolver.NoAnswer as e:
                logger.error('Record {0} ({1}) exists but has no content: {2}'.format(record, t, e))
                continue
            except dns.resolver.NoNameservers as e:
                logger.error(('Could not failover to a non-broken resolver when resolving {0} ({1}): '
                              '{2}').format(record, t, e))
                continue
        return(records)

    def _getMyIP(self):
        for v in self.my_ips.keys():
            try:
                logger.debug('Getting the client\'s WAN address for IPv{0}'.format(v))
                r = requests.get('https://ipv{0}.clientinfo.square-r00t.net/?raw=1'.format(v))
                if not r.ok:
                    logger.error('Got a non-OK response from WAN IPv{0} fetch.'.format(v))
                    raise RuntimeError('Could not get the IPv{0} address'.format(v))
                ip = r.json()['ip']
                logger.debug('Got WAN IP address {0} for IPv{1}'.format(ip, v))
                self.my_ips[v] = ip
            except requests.exceptions.ConnectionError:
                logger.debug('Could not get WAN address for IPv{0}; likely not supported on this network'.format(v))
        return()

    def _getSession(self):
        self.session = requests.Session()
        self.session.headers.update({'Authorization': 'Bearer {0}'.format(self.token)})
        return()

    def update(self):
        for d in self.records.keys():
            d_f = json.dumps({'domain': d})
            doms_url = '{0}/domains'.format(self.api_base)
            logger.debug('Getting list of domains from {0} (filtered to {1})'.format(doms_url, d))
            d_r = self.session.get(doms_url,
                                   headers = {'X-Filter': d_f})
            if not d_r.ok:
                e = 'Could not get list of domains when attempting to check {0}; skipping'.format(d)
                if is_tty:
                    warnings.warn(e)
                logger.warning(e)
                continue
            try:
                d_id = d_r.json()['data'][0]['id']
            except (IndexError, KeyError):
                e = 'Could not find domain {0} in the returned domains list; skipping'.format(d)
                if is_tty:
                    warnings.warn(e)
                logger.warning(e)
                continue
            for s in self.records[d]:
                fqdn = '{0}.{1}'.format(s, d)
                logger.debug('Processing {0}'.format(fqdn))
                records = self._getDNS(fqdn)
                for v, t in ((4, 'A'), (6, 'AAAA')):
                    ip = self.my_ips.get(v)
                    rrset = records.get(t)
                    if not ip:
                        e = 'IPv{0} disabled; skipping'.format(v)
                        warnings.warn(e)
                        if is_tty:
                            logger.warning(e)
                        continue
                    if rrset and ip in rrset:
                        e = 'Skipping adding {0} for {1}; already exists in DNS'.format(ip, fqdn)
                        logger.info(e)
                        if is_tty:
                            print(e)
                        continue
                    s_f = json.dumps({'name': s,
                                      'type': t})
                    records_url = '{0}/domains/{1}/records'.format(self.api_base, d_id)
                    logger.debug(('Getting list of records from {0} '
                                  '(filtered to name {1} and type {2})').format(records_url, s, t))
                    s_r = self.session.get(records_url,
                                           headers = {'X-Filter': s_f})
                    if not s_r.ok:
                        e = 'Could not get list of records when attempting to check {0} ({1}); skipping'.format(fqdn, t)
                        if is_tty:
                            warnings.warn(e)
                        logger.warning(e)
                        continue
                    r_ids = set()
                    # If r_exists is:
                    #   None, then the record exists but the current WAN IP is missing (all records replaced).
                    #   False, then the record does not exist (record will be added).
                    #   True, then the record exists and is current (nothing will be done).
                    r_exists = None
                    try:
                        api_records = s_r.json().pop('data')
                        for idx, r in enumerate(api_records):
                            r_ids.add(r['id'])
                            r_ip = r['target']
                            if r_ip == ip:
                                r_exists = True
                    except (IndexError, KeyError):
                        e = ('Could not find record {0} ({1}) in the returned records list; '
                             'creating new record').format(fqdn, t)
                        if is_tty:
                            print(e)
                        logger.info(e)
                        r_exists = False
                    if r_exists:
                        # Do nothing.
                        e = 'Skipping adding {0} for {1}; already exists in API'.format(ip, fqdn)
                        logger.info(e)
                        if is_tty:
                            print(e)
                        continue
                    elif r_exists is None:
                        # Remove all records and then add (at the end).
                        # We COULD do an update:
                        #   https://developers.linode.com/api/v4/domains-domain-id-records-record-id/#put
                        # BUT then we break future updating since we don't know which record is the "right" one to
                        # update.
                        logger.debug('Record {0} ({1}) exists but does not contain {2}; replacing'.format(fqdn, t, ip))
                        for r_id in r_ids:
                            del_url = '{0}/domains/{1}/records/{1}'.format(self.api_base, d_id, r_id)
                            logger.debug(('Deleting record ID {0} for {1} ({2})').format(r_id, fqdn, t))
                            del_r = self.session.delete(records_url)
                            if not del_r.ok:
                                e = 'Could not delete record ID {0} for {1} ({2}); skipping'.format(r_id, fqdn, t)
                                if is_tty:
                                    warnings.warn(e)
                                logger.warning(e)
                                continue
                    else:
                        # Create the record.
                        logger.debug('Record {0} ({1}) does not exist; creating'.format(fqdn, ip))
                    record = {'name': s,
                              'type': t,
                              'target': ip,
                              'ttl_sec': 300}
                    create_url = '{0}/domains/{1}/records'.format(self.api_base, d_id)
                    create_r = self.session.put(create_url,
                                                json = record)
                    if not create_r.ok:
                        e = 'Could not create record {0} ({1}); skipping'.format(fqdn, t)
                        if is_tty:
                            warnings.warn(e)
                        logger.warning(e)
                        continue
        return()


def parseArgs():
    args = argparse.ArgumentParser(description = ('Automatically update Linode DNS via their API'))
    args.add_argument('-c', '--config',
                      dest = 'cfg_path',
                      default = '~/.config/ddns.xml',
                      help = ('The path to the configuration file. Default: ~/.config/ddns.xml'))
    return(args)


def main():
    args = parseArgs().parse_args()
    u = Updater(**vars(args))
    u.update()
    return(None)


if __name__ == '__main__':
    main()