# coding=utf8

import sys, os, ssl, time, socket, errno, signal
from Crypto.Cipher import DES3
from d import D
from parms import Parms


class Node():

	class AllPortsBusy(Exception):
		"""všechny TCP porty pro server longtasks nebo pro peering jsou obsazeny"""

	blocking = True   # select mode zatím není implementovaný
	useSSLContext = False
	ctx = None
	UDPbroadcastGO = False

	def __init__(self, d, chan=Parms.sslchannel, host=Parms.srvhost, port=None, conn=True, tryPort=True, peering=False):
		self._issl = Parms.ssl
		self._chan = chan
		self._bindhost = host
		self._baseport = Parms.baseport + (self._chan * 10) + (0 if self._issl else 1)
		self._minport = self._baseport + 1
		self._maxport = self._baseport + 9
		self._baseid = "netnode {}SSL".format("" if self._issl else "non")
		self.d = D("{} {}".format(d.debid, self._baseid))
		self._srv_side = None
		self._UDPpasswd = "heslo"
		self._UDPbroadcast_addr = Parms.broadcast
		self._UDPbroadcast_port = Parms.udpport
		self._UDP_key = "PEER_IP"
		self._UDPbroadcastGO = False
		self.sslContext()
		if conn:			# TCP connect
			if peering:
				host, port = self.get_peerport()
			self.conn(host=host, port=port)
		else:				# socket bind
			if tryPort:		# hledej volný port
				self.bindtrynext(self._bindhost)
				if peering: self.send_peerport()
			else:			# zkus bind a případně čekej na uvolnění
				self.bindwait(self._bindhost)


	def get(self, size):
		try:
			if self.d.ll(5): self.d.log("get data from scfile...")
			data = self._scfile.read(size)
			if self.d.ll(5): self.d.log("{} bytes read".format(len(data)))
			return data
		except Exception as e:
				self.d.abend("read from socket", e)
				return -1


	def genget(self, size=-1):
		rest = size
		while rest != 0:
			n = rest if 0 < rest < Parms.bufSize else Parms.bufSize
			data = self.get(n)
			r = len(data)
			if r < 1: break
			rest = rest - r
			yield data

	def getnum(self):
		b = self._scfile.read(12).decode()
		num = int(b) if b else -2   # -2 = EOD, -1 = directory, 0 and higher = data size
		if self.d.ll(5): self.d.log("getnum, got {:012d} (-2 means EOD)".format(num))
		return num

	def getstr(self, decode = True):
		lb = self.getnum()
		if lb < 1:
			return ""
		else:
			_data = self._scfile.read(int(lb))
			return _data.decode() if decode else _data

	def getfn(self):
		return self.getstr()

	def getcmd(self):
		try:
			return self._scfile.read(8).decode().rstrip('_')
		except Exception as e:
			if isinstance(e, socket.timeout):
				if self.d.ll(4): self.d.log("getcmd timeout")
			else:
				self.d.log("I/O err: {}".format(e))
			return ""

	def receive_dir(self, fp, size, timestamp):
		os.makedirs(fp, exist_ok=True)
		os.utime(fp, (timestamp, timestamp))
		return True

	def receive_file(self, fp, size, timestamp, counter=None):
		if os.path.dirname(fp): os.makedirs(os.path.dirname(fp), exist_ok=True)
		tempfp = fp + ".dejsem.partX"
		with open(tempfp, mode='w+b') as f:
			for data in self.genget(size = size):
				if counter: counter.update(len(data))
				f.write(data)
		if os.path.getsize(tempfp) == size:
			os.rename(tempfp, fp)
			os.utime(fp, (timestamp, timestamp))
		return True

	def receive_stream(self, fp, size, counter=None):
		if os.path.dirname(fp): os.makedirs(os.path.dirname(fp), exist_ok=True)
		tempfp = fp + ".{}.partX".format(Parms.applName)
		with open(tempfp, mode='w+b') as f:
			for data in self.genget(size = size):
				if counter: counter.update(len(data))
				f.write(data)
		if os.path.getsize(tempfp) == size:
			os.rename(tempfp, fp)
		return True

	def put(self, data):
		if self.d.ll(5): self.d.log("PUT: data len={}, sending...".format(len(data)))
		try:
			l = self._scfile.write(data)
			if self.d.ll(5): self.d.log("PUT: data len={}, sent".format(l))
			self._scfile.flush()
		except Exception as e:
				self.d.abend("send err", e)
				return False
		return True

	def genput(self):
		try:
			while True:
				data = yield None
				self.put(data)
		except Exception as e:
			self.d.abend("write to socket", e)
			raise e
		finally:
			self._scfile.flush()

	def sendEOD(self):
		self.putnum(0)

	def putnum(self, n):
		if self.d.ll(5): self.d.log("putnum, num={:012d}".format(n))
		self._scfile.write(bytes("{:012d}".format(n), "utf8"))
		self._scfile.flush()

	def putstr(self, fn):
		b = bytes(str(fn), "utf8")
		self.putnum(len(b))
		if self.d.ll(5): self.d.log("putstr, string={}".format(fn))
		self._scfile.write(b)
		self._scfile.flush()

	def putcmd(self, act):
		if self.d.ll(3): self.d.log("action: " + act)
		# self._node.payload.data = bytes("{}".format(act), "utf8")
		self.put(bytes("{}".format(act.ljust(8, '_')), "utf8"))

	def sendport(self, port):
		"""send dynamically allocated port to client"""
		self.putnum(port)

	def putfileinfo(self, fp, relfp):
		if self.d.ll(5): self.d.log("putfileinfo fp={}, relfp={}...".format(fp, relfp))
		self.putstr(relfp)
		size = os.path.getsize(fp) if os.path.isfile(fp) else -1
		self.putnum(size)
		timestamp = int(os.path.getmtime(fp)) if os.path.exists(fp) else 0
		self.putnum(timestamp)
		if self.d.ll(4): self.d.log("fileinfo sent: fn={}, size={}, timestamp={}".format(relfp, size, timestamp))

	def digest(self):
		return self.data if len(self.data) < 24 else self.data[0:8].decode() + "--------" + self.data[-8:].decode()

	def sslContext(self):
		if self._issl:
			if Node.useSSLContext:
				if not Node.ctx:
					if self.d.ll(4): self.d.log(
						"setting SSL context: certfile={}, capath={}...".format(Parms.sslCert, Parms.sslCAPath))
					try:
						Node.ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)	# PROTOCOL_SSLv23
						Node.ctx.verify_mode = ssl.CERT_REQUIRED  		# CERT_REQUIRED	| CERT_OPTIONAL	| CERT_NONE
						Node.ctx.load_cert_chain(Parms.sslCert)
						Node.ctx.load_verify_locations(None, Parms.sslCAPath)
					except ssl.SSLError as e:
						self.d.abendHard("SSL context", e)

	def getssc(self):
		try:
			ssc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
			ssc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
		except Exception as e:
			self.d.abendHard("ssc alloc", e)
		if self._issl:
			try:
				if Node.useSSLContext:
					ssc = Node.ctx.wrap_socket(ssc, server_side=True)
				else:
					ssc = ssl.wrap_socket(
						ssc,
						certfile=Parms.sslCert,
						ca_certs=Parms.sslCAPath,
						server_side=True,
						cert_reqs=ssl.CERT_REQUIRED,
						ssl_version=ssl.PROTOCOL_TLSv1)
			except ssl.SSLError as e:
				self.d.abendHard("ssc SSL wrap", e)
		return ssc

	def bindwait(self, host):
		port = self._baseport
		self.d.log("binding to {}:{}".format(host, port))
		ssc = self.getssc()
		tries = 0
		while True:
			try:
				ssc.bind((host, port))
				break
			except Exception as e:
				if e.strerror == "Address already in use":
					if not tries: self.d.log("Address {}:{} already in use, waiting 10 secs...".format(host, port))
					tries = tries + 1 if tries < 77 else 0
					try:
						time.sleep(10)
					except KeyboardInterrupt:
						raise
					continue
				self.d.abendHard("bind", e)
			except KeyboardInterrupt:
				raise
		ssc.listen(1)
		if self.d.ll(2): self.d.log("bound to {}:{}".format(host, port))
		self._ssc = ssc
		self.port = port
		return ssc

	def bindtrynext(self, host):
		for port in range(self._minport, self._maxport + 1):
			if self.d.ll(4): self.d.log("trying to bind to {}:{}...".format(host, port))
			try:
				ssc = self.getssc()
				ssc.bind((host, port))
				ssc.listen(1)
				break
			except Exception as e:
				if e.strerror == "Address already in use":
					if port < self._maxport:
						continue
					raise Node.AllPortsBusy
				self.d.abend("bind", e)
		if self.d.ll(2): self.d.log("bound to {}:{}".format(host, port))
		self._ssc = ssc
		self.port = port
		return (ssc, port)

	def send_peerport(self):
		"""UDP broadcast host:port pair for peer"""
		ipport = "{:012d}{}{:012d}{}{:012d}".format(len(self._UDP_key), self._UDP_key, len(self._bindhost), self._bindhost, self.port)

		c = DES3.new(self.rawKey(self._UDPpasswd, 24), DES3.MODE_ECB)
		data = ipport.encode()
		enc = c.encrypt(data + b' ' * (8 - len(data) % 8))
		if self.d.ll(4): self.d.log("len=%d, enc=[%s]" % (len(enc), enc.hex()))
		s = socket.socket(type=socket.SOCK_DGRAM)
		s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
		a = (self._UDPbroadcast_addr, self._UDPbroadcast_port)
		if self.d.ll(4): self.d.log("start udp sending to {}:{}: {}".format(self._UDPbroadcast_addr, Parms.udpport, data.decode()))

		pid = os.fork()
		if pid: self._UDPbroadcastPID = pid
		else:
			self.UDPbroadcastGO = True
			signal.signal(signal.SIGHUP, self.UDPstop)
			signal.pthread_sigmask(signal.SIG_UNBLOCK, {signal.SIGHUP})
			retries = 777
			while retries > 0 and self.UDPbroadcastGO:
				s.sendto(enc, a)
				time.sleep(1)
				retries -= 1
			sys.exit(0)

	def get_peerport(self):
		"""get peer host:port pair broadcasted by peer via UDP"""
		c = DES3.new(self.rawKey(self._UDPpasswd, 24), DES3.MODE_ECB)
		s = socket.socket(type=socket.SOCK_DGRAM)
		a = ('', self._UDPbroadcast_port)
		if self.d.ll(4): self.d.log("binding to udp-port {}:{}".format(a[0], a[1]))
		s.bind(a)
		s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
		while True:
			(dataBytes, (ip, port)) = s.recvfrom(512)
			try:	# ignore bad dgrams
				data = c.decrypt(dataBytes).decode().strip() if Parms.ssl else dataBytes.decode()
			except: continue
			if self.d.ll(5): self.d.log("datalen={}, data={}".format(len(data), data))
			strlen = int(data[:12])
			key = data[12:12+strlen]
			if not key == self._UDP_key: continue
			data = data[12+strlen:]
			strlen = int(data[:12])
			host = data[12:12+strlen]
			port = int(data[12+strlen:])
			if self.d.ll(4): self.d.log("peer listening on {}:{}".format(host, port))
			return (host, port)

	def rawKey(self, passwd, keylen):
		key = b''
		while len(key) < keylen:
			key = key + passwd.encode()
		return key[:keylen]

	def UDPstop(self, sign, frame):
		self.UDPbroadcastGO = False

	def UDPsignalHUP(self):
		os.kill(self._UDPbroadcastPID, signal.SIGHUP)		# stop UDP broadcast

	def acc(self, acc_TO=Parms.peer_accept_timeout):
		if self.d.ll(4): self.d.log("accepting on {} ...".format(self.port))
		self._ssc.settimeout(acc_TO)
		try:
			self._sc, (froma, fromp) = self._ssc.accept()
		except KeyboardInterrupt:
			if self.d.ll(4): self.d.log("KeyboardInterrupt")
			raise
		except Exception as e:
			self.d.abend("accept", e)
			return False
		# fileno = self._sc.fileno()
		if self.d.ll(2): self.d.log("conn request on {}SSL port {} from {}:{}"
								.format("" if self._issl else "non", self.port, froma, fromp))
		if Node.blocking:
			self._sc.settimeout(Parms.blockTimeout)
		else:   # select mode není zatím implementovaný
			self._srv_side[self._sc] = self._sc
			if self.d.ll(3): self.d.log("srv side={}".format(*(sc.fileno() for sc in self._srv_side.values())))
		accepted = False
		commonName = "nonSSL"
		certSubject = {}
		if self._chan > 0 and self._issl:
			certSubject.update(i for (i,) in self._sc.getpeercert()['subject'])
			self.d.log("client certificate subject:", certSubject, sev=4)
			if "commonName" in certSubject: commonName = certSubject["commonName"]
			if commonName == "{:02d}".format(self._chan): accepted = True
			# alternativa
			# for ((key, value),) in sc.getpeercert().get("subject"):
			# 	if key == "commonName":
			# 		commonName = value
			# 		if commonName == "{:02d}".format(self._chan): accepted = True
		else:
			accepted = True
		if self.d.ll(2): self.d.log("client {} {}".format(certSubject["commonName"], "accepted" if accepted else "rejected"))
		try:
			self._scfile = self._sc.makefile("rwb")
		except Exception as e:
			self.d.abendMsg("socket-makefile", e=e)
			self.close_sc()
			return False
		if accepted:
			try:
				if self.d.ll(4): self.d.log("confirming accept")
				self._scfile.write(b"ACCEPTED")
				self._scfile.flush()
				return True
			except Exception as e:
				self.d.abendMsg("send confirm", e=e)
				self.close_sc()
				return False
		else:	
			self._scfile.write(b"REJECTED")
			self.close_sc()
		return False

	def conn(self, host=Parms.srvhost, port=None):
		if not port: port = self._baseport
		if self.d.ll(4): self.d.log("connecting to {}:{}...".format(host, port))
		try:
			self._sc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		except Exception as e:
			self.d.abend("socket alloc", e)
		if self._issl:
			if self.d.ll(4): self.d.log("sc SSL wrap, homedir={}, certfile={}, ca_certs={}"
									.format(os.getcwd(), Parms.sslCert, Parms.sslCAPath))
			try:
				if Node.useSSLContext:
					self._sc = Node.ctx.wrap_socket(self._sc)
				else:
					self._sc = ssl.wrap_socket(
						self._sc,
						certfile=Parms.sslCert,
						ca_certs=Parms.sslCAPath,
						cert_reqs=ssl.CERT_REQUIRED,
						ssl_version=ssl.PROTOCOL_TLSv1)
			except Exception as e:
				self.d.abend("sc SSL wrap", e)
		retry = Parms.connThreshold
		connected = False
		while not connected and retry > 0:
			try:
				self._sc.connect((host, port))
				connected = True
			except Exception as e:
				if e.errno == errno.ECONNREFUSED:
					retry = retry - 1
					time.sleep(Parms.connTimeout)
				else:
					self.d.abend("connect to {}".format(host), e)
		if retry == 0: self.d.abend("connection to {} refused, threshold {} reached".format(host, Parms.connThreshold), None)
		fileno = self._sc.fileno()
		if Node.blocking: self._sc.settimeout(Parms.blockTimeout)
		try:
			self._scfile = self._sc.makefile("rwb")
		except Exception as e:
			self.d.abend("connect makefile", e)
		try:
			if self._scfile.read(8) != b"ACCEPTED": self.d.abend("connection not accepted by server", None)
		except Exception as e:
			self.d.abend("read socket", e)
		if self.d.ll(2): self.d.log("connected to {}:{} after {} retries, via fd {}"
									.format(host, port, Parms.connThreshold - retry, fileno))

	def close_sc(self):
		if self.d.ll(4): self.d.log("closing socket...")
		try:
			if hasattr(self, '_scfile'): self._scfile.close()
			if hasattr(self, '_sc'): self._sc.close()
		except Exception as e:
			self.d.abend("closing socket", e)

	def close_ssc(self):
		if self.d.ll(4): self.d.log("closing SSL socket...")
		if hasattr(self, "_ssc"):
			try: self._ssc.close()
			except Exception as e: self.d.abend("closing SSL socket", e)

	def close(self):
		self.close_sc()
		self.close_ssc()