#!/usr/bin/python3
# vim:fileencoding=utf-8:noet
from __future__ import (unicode_literals, division, absolute_import, print_function)

import socket
import os
import errno
import sys
import fcntl
import atexit
import stat

from argparse import ArgumentParser
from select import select
from signal import signal, SIGTERM
from time import sleep
from functools import partial
from io import BytesIO
from threading import Event
from itertools import chain
from logging import StreamHandler

from powerline.shell import ShellPowerline
from powerline.commands.main import finish_args, write_output
from powerline.lib.monotonic import monotonic
from powerline.lib.encoding import get_preferred_output_encoding, get_preferred_arguments_encoding, get_unicode_writer
from powerline.bindings.wm import wm_threads

from powerline.commands.main import get_argparser as get_main_argparser
from powerline.commands.daemon import get_argparser as get_daemon_argparser


USE_FILESYSTEM = not sys.platform.lower().startswith('linux')


class NonInteractiveArgParser(ArgumentParser):
	def print_usage(self, file=None):
		raise Exception(self.format_usage())

	def print_help(self, file=None):
		raise Exception(self.format_help())

	def exit(self, status=0, message=None):
		pass

	def error(self, message):
		raise Exception(self.format_usage())


EOF = b'EOF\0\0'


class State(object):
	__slots__ = ('powerlines', 'logger', 'config_loader', 'started_wm_threads',
	             'ts_shutdown_event')

	def __init__(self, **kwargs):
		self.logger = None
		self.config_loader = None
		self.started_wm_threads = {}
		self.powerlines = {}
		self.ts_shutdown_event = Event()


HOME = os.path.expanduser('~')


class NonDaemonShellPowerline(ShellPowerline):
	def get_log_handler(self):
		return StreamHandler()


def start_wm(args, environ, cwd, is_daemon, state):
	wm_name = args.ext[0][3:]
	if wm_name in state.started_wm_threads:
		return b''
	thread_shutdown_event = Event()
	thread = wm_threads[wm_name](
		thread_shutdown_event=thread_shutdown_event,
		pl_shutdown_event=state.ts_shutdown_event,
		pl_config_loader=state.config_loader,
	)
	thread.start()
	state.started_wm_threads[wm_name] = (thread, thread_shutdown_event)
	return b''


def render(args, environ, cwd, is_daemon, state):
	segment_info = {
		'getcwd': lambda: cwd,
		'home': environ.get('HOME', HOME),
		'environ': environ,
		'args': args,
	}
	key = (
		args.ext[0],
		args.renderer_module,
		tuple(args.config_override) if args.config_override else None,
		tuple(args.theme_override) if args.theme_override else None,
		tuple(args.config_path) if args.config_path else None,
		environ.get('POWERLINE_THEME_OVERRIDES', ''),
		environ.get('POWERLINE_CONFIG_OVERRIDES', ''),
		environ.get('POWERLINE_CONFIG_PATHS', ''),
	)

	PowerlineClass = ShellPowerline if is_daemon else NonDaemonShellPowerline
	powerline = None
	try:
		powerline = state.powerlines[key]
	except KeyError:
		try:
			powerline = state.powerlines[key] = PowerlineClass(
				args,
				logger=state.logger,
				config_loader=state.config_loader,
				run_once=False,
				shutdown_event=state.ts_shutdown_event,
			)
			if state.logger is None:
				state.logger = powerline.logger
			if state.config_loader is None:
				state.config_loader = powerline.config_loader
		except SystemExit:
			# Somebody thought raising system exit was a good idea,
			return ''
		except Exception as e:
			if powerline:
				powerline.pl.exception('Failed to render {0}: {1}', str(key), str(e))
			else:
				return 'Failed to render {0}: {1}'.format(str(key), str(e))
	s = BytesIO()
	write_output(args, powerline, segment_info, get_unicode_writer(stream=s))
	s.seek(0)
	return s.read()


def eintr_retry_call(func, *args, **kwargs):
	while True:
		try:
			return func(*args, **kwargs)
		except EnvironmentError as e:
			if getattr(e, 'errno', None) == errno.EINTR:
				continue
			raise


def do_read(conn, timeout=2.0):
	''' Read data from the client. If the client fails to send data within
	timeout seconds, abort. '''
	read = []
	end_time = monotonic() + timeout
	while not read or not read[-1].endswith(b'\0\0'):
		r, w, e = select((conn,), (), (conn,), timeout)
		if e:
			return
		if monotonic() > end_time:
			return
		if not r:
			continue
		x = eintr_retry_call(conn.recv, 4096)
		if x:
			read.append(x)
		else:
			break
	return b''.join(read)


def do_write(conn, result):
	try:
		eintr_retry_call(conn.sendall, result)
	except Exception:
		pass


def safe_bytes(o, encoding=get_preferred_output_encoding()):
	'''Return bytes instance without ever throwing an exception.'''
	try:
		try:
			# We are assuming that o is a unicode object
			return o.encode(encoding, 'replace')
		except Exception:
			# Object may have defined __bytes__ (python 3) or __str__ method 
			# (python 2)
			# This also catches problem with non_ascii_bytes.encode('utf-8') 
			# that first tries to decode to UTF-8 using ascii codec (and fails 
			# in this case) and then encode to given encoding: errors= argument 
			# is not used in the first stage.
			return bytes(o)
	except Exception as e:
		return safe_bytes(str(e), encoding)


def parse_args(req, parser, encoding=get_preferred_arguments_encoding()):
	args = [x.decode(encoding) for x in req.split(b'\0') if x]
	numargs = int(args[0], 16)
	shell_args = parser.parse_args(args[1:numargs + 1])
	cwd = args[numargs + 1]
	environ = dict(((k, v) for k, v in (x.partition('=')[0::2] for x in args[numargs + 2:])))
	cwd = cwd or environ.get('PWD', '/')
	return shell_args, environ, cwd


def get_answer(req, is_daemon, argparser, state):
	try:
		args, environ, cwd = parse_args(req, argparser)
		finish_args(argparser, environ, args, is_daemon=True)
		if args.ext[0].startswith('wm.'):
			return safe_bytes(start_wm(args, environ, cwd, is_daemon, state))
		else:
			return safe_bytes(render(args, environ, cwd, is_daemon, state))
	except Exception as e:
		return safe_bytes(str(e))


def do_one(sock, read_sockets, write_sockets, result_map, is_daemon, argparser,
           state):
	r, w, e = select(
		tuple(read_sockets) + (sock,),
		tuple(write_sockets),
		tuple(read_sockets) + tuple(write_sockets) + (sock,),
		60.0
	)

	if sock in e:
		# We cannot accept any more connections, so we exit
		raise SystemExit(1)

	for s in e:
		# Discard all broken connections to clients
		s.close()
		read_sockets.discard(s)
		write_sockets.discard(s)

	for s in r:
		if s == sock:
			# A client wants to connect
			conn, _ = eintr_retry_call(sock.accept)
			read_sockets.add(conn)
		else:
			# A client has sent some data
			read_sockets.discard(s)
			req = do_read(s)
			if req == EOF:
				raise SystemExit(0)
			elif req:
				ans = get_answer(req, is_daemon, argparser, state)
				result_map[s] = ans
				write_sockets.add(s)
			else:
				s.close()

	for s in w:
		# A client is ready to receive the result
		write_sockets.discard(s)
		result = result_map.pop(s)
		try:
			do_write(s, result)
		finally:
			s.close()


def shutdown(sock, read_sockets, write_sockets, state):
	'''Perform operations necessary for nicely shutting down daemon

	Specifically it

	#. Closes all sockets.
	#. Notifies segments based on 
	  :py:class:`powerline.lib.threaded.ThreadedSegment` and WM-specific 
	  threads that daemon is shutting down.
	#. Waits for threads to finish, but no more then 2 seconds total.
	#. Waits so that total execution time of this function is 2 seconds in order 
	   to allow ThreadedSegments to finish.
	'''
	total_wait_time = 2
	shutdown_start_time = monotonic()

	for s in chain((sock,), read_sockets, write_sockets):
		s.close()

	# Notify ThreadedSegments
	state.ts_shutdown_event.set()
	for thread, shutdown_event in state.started_wm_threads.values():
		shutdown_event.set()

	for thread, shutdown_event in state.started_wm_threads.values():
		wait_time = total_wait_time - (monotonic() - shutdown_start_time)
		if wait_time > 0:
			thread.join(wait_time)

	wait_time = total_wait_time - (monotonic() - shutdown_start_time)
	sleep(wait_time)


def main_loop(sock, is_daemon):
	sock.listen(128)
	sock.setblocking(0)

	read_sockets, write_sockets = set(), set()
	result_map = {}
	parser = get_main_argparser(NonInteractiveArgParser)
	state = State()
	try:
		try:
			while True:
				do_one(
					sock, read_sockets, write_sockets, result_map,
					is_daemon=is_daemon,
					argparser=parser,
					state=state,
				)
		except KeyboardInterrupt:
			raise SystemExit(0)
	except SystemExit as e:
		shutdown(sock, read_sockets, write_sockets, state)
		raise e
	return 0


def daemonize(stdin=os.devnull, stdout=os.devnull, stderr=os.devnull):
	try:
		pid = os.fork()
		if pid > 0:
			# exit first parent
			raise SystemExit(0)
	except OSError as e:
		sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
		raise SystemExit(1)

	# decouple from parent environment
	os.chdir("/")
	os.setsid()
	os.umask(0)

	# do second fork
	try:
		pid = os.fork()
		if pid > 0:
			# exit from second parent
			raise SystemExit(0)
	except OSError as e:
		sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
		raise SystemExit(1)

	# Redirect standard file descriptors.
	si = open(stdin, 'rb')
	so = open(stdout, 'a+b')
	se = open(stderr, 'a+b', 0)
	os.dup2(si.fileno(), sys.stdin.fileno())
	os.dup2(so.fileno(), sys.stdout.fileno())
	os.dup2(se.fileno(), sys.stderr.fileno())
	return True


def check_existing(address):
	if USE_FILESYSTEM:
		# We cannot bind if the socket file already exists so remove it, we
		# already have a lock on pidfile, so this should be safe.
		try:
			os.unlink(address)
		except EnvironmentError:
			pass

	sock = socket.socket(family=socket.AF_UNIX)
	try:
		sock.bind(address)
	except socket.error as e:
		if getattr(e, 'errno', None) == errno.EADDRINUSE:
			return None
		raise
	return sock


def kill_daemon(address):
	sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
	try:
		try:
			eintr_retry_call(sock.connect, address)
		except socket.error:
			return False
		else:
			eintr_retry_call(sock.sendall, EOF)
	finally:
		sock.close()
	return True


def cleanup_lockfile(pidfile, fd, *args):
	try:
		# Remove the directory entry for the lock file
		os.unlink(pidfile)
		# Close the file descriptor
		os.close(fd)
	except EnvironmentError:
		pass
	if args:
		# Called in signal handler
		raise SystemExit(1)


def lockpidfile(pidfile):
	fd = os.open(
		pidfile,
		os.O_WRONLY | os.O_CREAT,
		stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH
	)
	try:
		fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
	except EnvironmentError:
		os.close(fd)
		return None
	os.lseek(fd, 0, os.SEEK_SET)
	os.ftruncate(fd, 0)
	os.write(fd, ('%d' % os.getpid()).encode('ascii'))
	os.fsync(fd)
	cleanup = partial(cleanup_lockfile, pidfile, fd)
	signal(SIGTERM, cleanup)
	atexit.register(cleanup)
	return fd


def main():
	parser = get_daemon_argparser()
	args = parser.parse_args()
	is_daemon = False
	address = None
	pidfile = None

	if args.socket:
		address = args.socket
		if not USE_FILESYSTEM:
			address = '\0' + address
	else:
		if USE_FILESYSTEM:
			address = '/tmp/powerline-ipc-%d'
		else:
			# Use the abstract namespace for sockets rather than the filesystem
			# (Available only in linux)
			address = '\0powerline-ipc-%d'

		address = address % os.getuid()

	if USE_FILESYSTEM:
		pidfile = address + '.pid'

	if args.kill:
		if args.foreground or args.replace:
			parser.error('--kill and --foreground/--replace cannot be used together')
		if kill_daemon(address):
			if not args.quiet:
				print ('Kill command sent to daemon, if it does not die in a couple of seconds use kill to kill it')
			raise SystemExit(0)
		else:
			if not args.quiet:
				print ('No running daemon found')
			raise SystemExit(1)

	if args.replace:
		while kill_daemon(address):
			if not args.quiet:
				print ('Kill command sent to daemon, waiting for daemon to exit, press Ctrl-C to terminate wait and exit')
			sleep(2)

	if USE_FILESYSTEM and not args.foreground:
		# We must daemonize before creating the locked pidfile, unfortunately,
		# this means further print statements are discarded
		is_daemon = daemonize()

	if USE_FILESYSTEM:
		# Create a locked pid file containing the daemon’s PID
		if lockpidfile(pidfile) is None:
			if not args.quiet:
				sys.stderr.write(
					'The daemon is already running. Use %s -k to kill it.\n' % (
						os.path.basename(sys.argv[0])))
			raise SystemExit(1)

	# Bind to address or bail if we cannot bind
	sock = check_existing(address)
	if sock is None:
		if not args.quiet:
			sys.stderr.write(
				'The daemon is already running. Use %s -k to kill it.\n' % (
					os.path.basename(sys.argv[0])))
		raise SystemExit(1)

	if not USE_FILESYSTEM and not args.foreground:
		# We daemonize on linux
		is_daemon = daemonize()

	return main_loop(sock, is_daemon)


if __name__ == '__main__':
	main()