#!/usr/bin/env python3
'''Simple Dynamic DNS updater'''

import os
import sys
import subprocess
import argparse
import ast
import dataclasses
from time import sleep
from abc import ABC, abstractmethod
from typing import NoReturn, Optional, Any
from pathlib import Path
import requests

VERSION = '0.1.0'

def parse_args() -> argparse.Namespace:
	'''Parse command-line arguments'''
	parser = argparse.ArgumentParser(prog='simpleddns',
		description='Simple dynamic DNS updater',
		formatter_class=argparse.RawDescriptionHelpFormatter,
		epilog='''configuration:
        Configure SimpleDDNS by running with --setup or editing the file
        ~/.config/simpleddns/config (or $SIMPLEDDNS_CONFIG_DIR/config).
        There you should find comments documenting the various options.

environment variables:
        SIMPLEDDNS_CONFIG_DIR - directory where configburation files are stored''')
	parser.add_argument('--setup', help='Set up configuration', action='store_true')
	parser.add_argument('--dry-run',
		help='Print what API calls would be made, without actually making any non-GET calls.',
		action='store_true')
	parser.add_argument('--version', action='version', version=f'%(prog)s {VERSION}')
	return parser.parse_args()

def fatal_error(message: str) -> NoReturn:
	'''Output error message & exit'''
	sys.stderr.write(f'Fatal error: {message}\n')
	sys.exit(1)

def warn(message: str) -> None:
	'''Print warning message'''
	sys.stderr.write(f'WARNING: {message}\n')

def setup_config(config_path: Path) -> None:
	'''Interactively set up configuration file'''
	if config_path.exists():
		should_delete = input('Configuration already exists. Delete it [y/n]? ')
		if not should_delete.strip().lower().startswith('y'):
			print('Aborting.')
			return
		config_path.unlink()
	default_get_ip = 'curl --no-progress-meter ifconfig.co'
	domain_name = input('Domain name? ').strip()
	if not domain_name:
		fatal_error('Domain name must be set')
	get_ip = input(f'Command for getting IP address [default: {default_get_ip}]? ').strip()
	if not get_ip:
		get_ip = default_get_ip
	if any(c.isspace() for c in domain_name):
		fatal_error('Domain name must not contain any whitespace')
	print('1. Linode Domains')
	# TODO: AWS
	domain_type = input('Select a domain type from the list above [1-1]: ').strip()
	if domain_type == '1':
		access_token = input('Enter personal access token: ')
		options = f'''# Personal access token (secret!!)
    access_token = {repr(access_token)}'''
		type_name = 'linode'
	else:
		print('Invalid choice')
		return
	fd = os.open(config_path, os.O_CREAT | os.O_WRONLY | os.O_EXCL, 0o600)
	with os.fdopen(fd, 'w') as config:
		config.write(f'''Settings
    # Interval in seconds between checking IP address for changes
    #  (API calls are only made when it changes)
    interval = 15
    # Timeout to wait for API responses
    timeout = 20
    # Time To Live (in seconds) with which to create DNS records
    ttl = 300
    # Delay between API calls (seconds), to avoid being rate limited.
    #  0.4 seconds should be more than enough for both Linode and AWS,
    #  but you may want to set this higher if you have other things
    #  making frequent API calls.
    request_delay = 0.4
Domain {type_name} {domain_name}
    # Command(s) for getting IP address(es)
    getip = [{repr(get_ip)}]
    {options}
''')
	print(f'Configuration created successfully at {config_path}')

@dataclasses.dataclass
class Settings:
	'''Global (i.e. not per-domain) settings'''
	dry_run: bool = False
	interval: int = 15
	timeout: int = 20
	ttl: int = 300
	request_delay: float = 0.4

class Domain(ABC):
	'''A domain whose DNS will be updated'''
	full_domain: str
	root_domain: str
	subdomain: str
	getip: list[str]
	settings: Settings
	last_ips: list[str]
	_had_error: bool
	def __init__(self, settings: Settings, domain: str):
		self.settings = settings
		self.full_domain = domain
		last_dot = domain.rfind('.')
		if last_dot == -1:
			raise ValueError(f'Domain {domain} has no . in it')
		second_last_dot = domain.rfind('.', 0, last_dot)
		if second_last_dot == -1:
			self.subdomain = ''
			self.root_domain = domain
		else:
			self.subdomain = domain[:second_last_dot]
			self.root_domain = domain[second_last_dot+1:]
		self.last_ips = []
		self._init()
	def _info(self, message: str) -> None:
		'''Print informational message prefixed with domain name'''
		print(f'{self.full_domain}: {message}')
	def _error(self, message: str) -> None:
		'''Print warning and set _had_error field to True.'''
		self._had_error = True
		warn(message)
	def _ttl(self) -> int:
		'''Get TTL value to use for records for this domain'''
		return getattr(self, 'ttl', 0) or self.settings.ttl
	def _timeout(self) -> int:
		'''Get API request timeout'''
		return getattr(self, 'timeout', 0) or self.settings.timeout
	def _request_delay(self) -> float:
		'''Get delay between requests (seconds)'''
		return getattr(self, 'request_delay', 0) or self.settings.request_delay
	@abstractmethod
	def _init(self) -> None:
		'''Extra provider-specific initialization'''
	@abstractmethod
	def update(self, ips: list[str]) -> bool:
		'''Make necessary API request to update domain to use new IP addresses.
		   Returns False on failure.'''
	@abstractmethod
	def validate_specifics(self) -> str:
		'''Validate provider-specific settings for domain'''
	def validate(self) -> str:
		'''Validate this object (ensure all required settings are set)'''
		if not getattr(self, 'getip', ''):
			return 'getip not set'
		if not isinstance(self.getip, list):
			return 'getip should be a list.'
		return self.validate_specifics()
	def get_ips(self) -> list[str]:
		'''Get IP addresses using the registered commands.'''
		ips = []
		for cmd in self.getip:
			result = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, check=False)
			if result.returncode:
				warn(f'{self.getip} failed (exit code {result.returncode})')
				return []
			ip = result.stdout.decode(errors='replace').strip()
			# this test isn't perfect, but it should catch most cases of weird stuff
			if not ip or '..' in ip or any(c not in '0123456789abcdefABCDEF:.' for c in ip):
				warn(f'IP address {repr(ip)} is invalid')
				return []
			ips.append(ip)
		ips.sort()
		return ips
	def check_for_update(self) -> bool:
		'''Update DNS records if IP has changed. Returns False on error.'''
		ips = self.get_ips()
		if ips == self.last_ips:
			return True
		self._info('Dealing with new IP address(es)... ')
		sys.stdout.flush()
		if self.update(ips):
			self.last_ips = ips
			return True
		return False

class LinodeDomain(Domain):
	'''Domain registered with Linode Domains'''
	access_token: str
	# Domain ID for Linode API
	_id: Optional[int]
	def _init(self) -> None:
		self._id = None
	def __repr__(self) -> str:
		return f'<LinodeDomain domain={self.full_domain} ' \
			'getip={repr(self.getip)} ' \
			'access_token={repr(self.access_token)}>'
	def _headers(self, has_body: bool = False) -> dict[str, str]:
		'''Get HTTP headers for making requests'''
		headers = {'Accept': 'application/json', 'Authorization': f'Bearer {self.access_token}'}
		if has_body:
			headers['Content-Type'] = 'application/json'
		return headers
	def _make_request(self, method: str, url: str, body: Any = None) -> Any:
		sleep(self._request_delay())
		headers = self._headers(has_body = body is not None)
		options: dict[Any, Any] = {
			'headers': headers,
			'timeout': self._timeout(),
			'method': method,
			'url': url
		}
		if body is not None:
			options['json'] = body
		try:
			response = requests.request(**options)
			if not response.ok:
				self._error(f'''Got error response from endpoint {repr(url)} (code {response.status_code}):
{response.text}''')
			response_json = response.json()
			if response_json is None:
				self._error(f'Got null response from endpoint {repr(url)}')
			return response_json
		except requests.JSONDecodeError as e:
			self._error(f'Invalid JSON at endpoint {repr(url)}: {e}')
			return None
		except requests.RequestException as e:
			self._error(f'Error making request to {repr(url)}: {e}')
			return None
	def _paginated_get(self, url: str) -> list[Any]:
		'''Get results for a Linode paginated GET API endpoint.'''
		results = []
		page_size = 500
		for page in range(1, 100):
			page_url = f'{url}{"&" if "?" in url else "?"}page={page}&page_size={page_size}'
			response_json = self._make_request('GET', page_url)
			if response_json is None:
				break
			try:
				response_data = response_json['data']
				if not isinstance(response_data, list):
					raise ValueError('"data" member is not a list')
			except (KeyError, ValueError) as e:
				self._error(f'Bad JSON format at endpoint {repr(page_url)}: {e}')
				break
			results.extend(response_data)
			if len(response_data) < page_size:
				# Reached last page, presumably
				break
			if page == 99:
				self._error(f'Giving up after 99 pages of responses to API endpoint {repr(url)}')
		return results

	def _update_record(self, record_id: int, target: str) -> None:
		'''Update A/AAAA record to point to new IP address.'''
		if self.settings.dry_run:
			self._info(f'Update DNS record {record_id} (ttl = {self._ttl()}, target = {target})')
		else:
			payload = {
				'name': self.subdomain,
				'target': target,
				'ttl_sec': self._ttl()
			}
			url = f'https://api.linode.com/v4/domains/{self._id}/records/{record_id}'
			resp = self._make_request('PUT', url, payload)
			if isinstance(resp, dict):
				self._info(f'Successfully updated record {record_id} ' \
					f'with TTL = {self._ttl()}, target = {target}')

	def _delete_record(self, record_id: int) -> None:
		'''Delete DNS record'''
		if self.settings.dry_run:
			self._info(f'Delete DNS record {record_id}')
		else:
			url = f'https://api.linode.com/v4/domains/{self._id}/records/{record_id}'
			resp = self._make_request('DELETE', url)
			if isinstance(resp, dict):
				self._info(f'Successfully deleted record {record_id}')

	def _create_record(self, target: str) -> None:
		'''Create A/AAAA record for target IP address'''
		kind = 'AAAA' if ':' in target else 'A'
		if self.settings.dry_run:
			self._info(f'Add {kind} DNS record (ttl = {self._ttl()}, target = {target})')
		else:
			payload = {
				'type': kind,
				'name': self.subdomain,
				'target': target,
				'ttl_sec': self._ttl(),
			}
			url = f'https://api.linode.com/v4/domains/{self._id}/records'
			resp = self._make_request('POST', url, payload)
			if isinstance(resp, dict):
				self._info(f'Successfully created {kind} record with TTL = {self._ttl()}, target = {target}')

	def update(self, ips: list[str]) -> bool:
		self._had_error = False
		if self._id is None:
			domains = self._paginated_get('https://api.linode.com/v4/domains')
			if self._had_error:
				return False
			for domain in domains:
				domain_name = domain['domain']
				if self.root_domain == domain_name:
					# this is it!
					self._id = domain['id']
			if self._id is None:
				warn(f'Domain {self.root_domain} not found in Linode. Are you sure it is set up there?')
				return False
		records = self._paginated_get(f'https://api.linode.com/v4/domains/{self._id}/records')
		remaining_ips = set(ips)
		unused_records: dict[str, list[int]] = {'A': [], 'AAAA': []}
		for record in records:
			if record['type'] not in ['A', 'AAAA']:
				continue
			if record['name'] != self.subdomain:
				continue
			if record['target'] in remaining_ips and record['ttl_sec'] == self._ttl():
				# This record covers an IP address we want.
				remaining_ips.remove(record['target'])
				continue
			unused_records[record['type']].append(record['id'])
		if not remaining_ips and not any(v for v in unused_records.values()):
			self._info('No updates needed.')
			return True
		could_update = set()
		# Update existing records if possible (to save on API calls)
		for ip in remaining_ips:
			kind = 'AAAA' if ':' in ip else 'A'
			if unused_records[kind]:
				record_id = unused_records[kind].pop()
				self._update_record(record_id, ip)
				could_update.add(ip)
		remaining_ips -= could_update
		for record_id in (x for rs in unused_records.values() for x in rs):
			self._delete_record(record_id)
		for ip in remaining_ips:
			self._create_record(ip)
		return not self._had_error

	def validate_specifics(self) -> str:
		if not getattr(self, 'access_token', ''):
			return 'Access token not set'
		# OK
		return ''

def parse_config(config_path: Path) -> tuple[Settings, list[Domain]]:
	'''Parse configuration file'''
	curr_section: Settings | Domain | None = None
	settings = Settings()
	domains: list[Domain] = []
	with open(config_path, encoding='utf-8') as config:
		for line in config:
			line = line.strip()
			if line[0] == '#':
				# comment
				continue
			if line.startswith('Settings'):
				if isinstance(curr_section, Domain):
					domains.append(curr_section)
				curr_section = settings
			elif line.startswith('Domain '):
				if isinstance(curr_section, Domain):
					domains.append(curr_section)
				parts = line.split()
				if len(parts) != 3:
					fatal_error('Domain declaration should have exactly ' \
						'two space-separated arguments (type and name)')
				kind = parts[1]
				domain_name = parts[2]
				if kind == 'linode':
					curr_section = LinodeDomain(settings, domain_name)
				else:
					fatal_error(f'No such domain type: {kind}')
			else:
				if not curr_section:
					fatal_error('First non-empty line of configuration must be a Domain declaration or Settings')
				parts = [part.strip() for part in line.split('=', maxsplit=1)]
				if len(parts) != 2:
					fatal_error(f'Invalid syntax (want key = value): {line}')
				[key, value] = parts
				setattr(curr_section, key, ast.literal_eval(value))
	if isinstance(curr_section, Domain):
		domains.append(curr_section)
	for domain in domains:
		err = domain.validate()
		if err:
			fatal_error(f'In domain {domain.full_domain}: {err}')
	return (settings, domains)

def main() -> None:
	'''Run simpleddns'''
	args = parse_args()
	simpleddns_config_dir = os.getenv('SIMPLEDDNS_CONFIG_DIR')
	xdg_config_dir = os.getenv('XDG_CONFIG_DIR')
	if simpleddns_config_dir:
		config_dir = Path(simpleddns_config_dir)
	elif xdg_config_dir:
		config_dir = Path(xdg_config_dir, 'simpleddns')
	else:
		config_dir = Path('~/.config/simpleddns').expanduser()
	os.makedirs(config_dir, exist_ok = True)
	config_path = Path(config_dir, 'config')
	if args.setup:
		setup_config(config_path)
		sys.exit(0)
	if not config_path.exists():
		fatal_error("Configuration doesn't exist. Try running with --setup first.")
	if os.name == 'posix':
		config_mode = config_path.stat().st_mode
		if config_mode & 0o4:
			fatal_error(f'''DANGER: configuration file {config_path} allows
	reading by other users (mode {config_mode & 0o777:o}).
	If there are API tokens in there, revoke them immediately!!''')

	settings, domains = parse_config(config_path)
	settings.dry_run = args.dry_run
	if not domains:
		fatal_error('No domains defined. Try running with --setup?')
	print('simpleddns started.')
	while True:
		for domain in domains:
			domain.check_for_update()
		sleep(settings.interval)

if __name__ == '__main__':
	main()