# coding=utf8

import socket, os, sys, time, signal, subprocess

from d import D

from parms import Parms

from node import Node

from counter import Counter

# síťové operace klienta

#	- connect to remote server na base_port+CCx

#	- connect to remote peer na host:port, které dostane ze serveru na base_port+CC0 operací GETPEER

#	- listen for peer on base_port+CCx - konkrétní host:port zveřejňuje peer na serveru na base_port+CC0 operací SETPEER

#		- formalizace čísla portu je ovšem nutná jen když oba peers běží na tomtéž stroji

class Client():

	def __init__(self, d):

		self.d = D("client".format(d.debid))

		Parms.clientMode = True

		self._orig = Parms.orig		# origin data paths

		self._dest = Parms.dest		# destination data path

		self._chan = Parms.sslchannel

		if self.d.ll(1): self.d.log("pgm={}, homedir={}, action={}, channel={}, debug={}"

									.format(sys.argv[0], Parms.client_homedir, Parms.action, self._chan, Parms.debugLevel))

		if self.d.ll(3): self.d.log("CE path: {}, CA path: {}".format(Parms.sslCert, Parms.sslCAPath))

		act = Parms.action

		if	 not act:

			return

		elif act == "PUSHCLIP":     # from cliboard to remote server

			self.pushclip("clipboard")

		elif act == "PUSHPRIM":     # from X primary to remote server

			self.pushclip("primary")

		elif act == "PUSHFILE":     # from local files to remote server

			self.pushfile()

		elif act == "PUSHPEER":     # from local files to remote peer

			self.pushpeer()

		elif act == 'PULLCLIP':     # from remote server to cliboard

			self.pullclip()

		elif act == 'PULLHIST':     # synchronize local clipboard history from server

			self.pullhist()

		elif act == 'PULLFILE':     # from remote server files to local

			self.pullfile()

		elif act == 'PULLLIST':     # filelist of server dir

			self.pulllist()

		elif act == "PULLPEER":     # from remote peer to local

			self.pullpeer()

		elif act == "SRVHACK":

			self.srv_hack()

		elif act == "HACK":

			self.hack()

		else:

			self.d.log("ABEND, unknown command {}".format(act))

		if hasattr(self, "_node"):

			self._node.close_sc()

			self._node.close_ssc()

	def pushclip(self, buffer):

		p = subprocess.Popen(["xclip", "-o", "-selection", buffer], stdout=subprocess.PIPE)

		if not p.stdout.read().lstrip():    	# nejdřív ověřit, že na clipboardu něco visí

			self.d.abend("{} buf is empty".format(buffer), None)

		self._node = Node(self.d, conn=True)    # establish server cmd session

		self._node.putcmd("PUSHCLIP")

		if self.d.ll(3): self.d.log("push clipboard starting...")

		p = subprocess.Popen(["xclip", "-o", "-selection", buffer], stdout=subprocess.PIPE)

		self._node.put(p.stdout.read())

		p.wait()

		if self.d.ll(2): self.d.log("push clipboard end")

	def longtask(self):

		# příkaz serveru k otevření paralelního portu pro dlouhý přenos

		# dostanu číslo portu, uvolním příkazový port a otevřu conn na nový port

		self._node.putcmd("LONGTASK")

		port = self._node.getnum()

		if port == 0:

			self.d.abend("all server net ports are busy", None)

		self._node.close()     # free server base port 0

		self._node = Node(self.d, port=port)

	def pushfile(self):

		if not self._orig:

			self.d.abendMsg("nothing specified")

		else:

			if not self._dest and len(self._orig) > 1:  # je-li na vstupu více jmen, tak poslední je destdir

				self._dest = os.path.normpath(self._orig[-1])

				if self._dest.startswith('/'): self._dest = self._dest[1:]  # výstup jenom relativně

				del self._orig[-1]

			if not any(os.path.exists(p) for p in self._orig):

				self.d.abendMsg("{} not found".format(self._orig))

			else:

				self._node = Node(self.d, conn=True)

				self.longtask()     # přechod na datový port

				self._counter = Counter(self.d, self.batchSize())    # start transfer progress display

				self._node.putcmd("PUSHFILE")

				for fp in self._orig:

					if self.d.ll(3): self.d.log("pushfile '{}' --> '{}' starting...".format(fp, self._dest))

					if os.path.exists(fp):

						normfp = os.path.normpath(fp)

						self.pushfile_recurse(normfp, os.path.dirname(normfp))

					else:

						self.d.warn("pushfile: {} not found".format(fp))

				self._counter.stop()

				self.d.log("pushfile end", sev=2)

	def pushfile_recurse(self, fp, prefix):

		if self.d.ll(4): self.d.log("fp={}, relative fp={}".format(fp, os.path.relpath(fp, prefix)))

		dest = os.path.join(self._dest, os.path.relpath(fp, prefix))

		if os.path.isdir(fp):

			for cwd, void, entries in os.walk(fp, topdown=True):

				for entry in entries:

					if self.d.ll(4): self.d.log("cwd={}, entry={}".format(cwd, entry))

					self.pushfile_recurse(os.path.join(cwd, entry), prefix)

				self._node.putfileinfo(cwd, os.path.join(self._dest, os.path.relpath(cwd, prefix)))

			self._node.putfileinfo(fp, dest)

		else:

			self._node.putfileinfo(fp, dest)

			with open(fp, mode='rb') as f:

				g = self._node.genput()

				g.send(None)

				data = f.read(Parms.bufSize)

				while data:

					self._counter.update(len(data))

					if self.d.ll(5): self.d.log("push file: len read from file={}".format(len(data)))

					try:

						g.send(data)

						data = f.read(Parms.bufSize)

					except Exception:

						break

				g.close()

	def pullclip(self):

		self._node = Node(self.d, conn=True)	# establish server cmd session

		self._node.putcmd("PULLCLIP")

		self._node.putstr("")   # empty str means LAST entry in clipboard storage on server

		if self.d.ll(3): self.d.log("pull clipboard starting...")

		p = subprocess.Popen(["xclip", "-i", "-selection", "clipboard"], stdin=subprocess.PIPE)

		for data in self._node.genget(size = self._node.getnum()):

			p.stdin.write(data)

		p.stdin.close()

		p.wait()

		self._node.close_sc()

		if self.d.ll(2): self.d.log("pull clipboard end")

	def pullhist(self):

		"""

		synchronizace historie clipboardu se serverem

		- entries z clipboardu se drží na serveru v jednotlivých souborech, které se synchronizují do lokálního dir

		- po synchrnizaci se vytvoří indexový soubor seřazený podle timestampů

		"""

		histdir = Parms.client_histdir

		self._node = Node(self.d, conn=True)      # establish server cmd session

		self._node.putcmd("PULLHIST")

		self.d.log("synchronizing clipboard history...")

		os.makedirs(histdir, mode=0o755, exist_ok=True)

		os.chdir(histdir)

		entries = dict()

		toget = dict()

		fn = self._node.getfn()

		while len(fn) > 0:	# inventarizace serveru

			if self.d.ll(5): self.d.log("fn=" + fn)

			# entries obsahují prvních 80 bytů z clipboard entry, délku clipboard entry a timestamp

			# entries mohou být binární i textové, takže se nedekódují

			entries[fn] = (self._node.getstr(decode=False), self._node.getnum(), self._node.getnum())

			if not os.path.exists(fn):

				toget[fn] = entries[fn]

				if self.d.ll(4): self.d.log("fn {} doesn't exists, toget[fn]={}, toget size={}".format(fn, toget[fn], len(toget)))

			fn = self._node.getfn()

		self.d.log("toget={}, toget size={}".format(toget.keys(), len(toget)), sev=4)

		if len(toget):		# synchronizace

			for fn in toget.keys():

				self._node.putcmd("PULLCLIP")

				self._node.putstr(fn)                           # send requested entry name

				with open(fn, mode='wb') as f:

					for data in self._node.genget(size = self._node.getnum()):

						f.write(data)

				timestamp = toget[fn][2]

				os.utime(fn, (timestamp, timestamp))

			self._node.close_sc()

		p = subprocess.Popen(["sort", "-k2", "-r"], stdin=subprocess.PIPE, stdout=open('.index', mode='w'), universal_newlines=True)

		for fn in os.listdir():	# indexing

			if fn == ".index": continue

			digest = open(fn, mode="rb").read(80).replace(b'\n', b' ')

			try: digest = digest.decode()	# to, co nepůjde dekódovat, necháme být

			except UnicodeDecodeError: pass

			size = os.path.getsize(fn)

			timestamp = int(os.path.getmtime(fn))

			p.stdin.write("{} {} {: 6d} {}\n".format(fn, time.strftime("%Y/%m/%d.%H:%M:%S", time.gmtime(timestamp)), size, digest))

		p.stdin.close()

		p.wait()

		if p.returncode == 0:

			p = subprocess.Popen(["mc", histdir])

			p.wait()

		if self.d.ll(5): self.d.log("clipboard history sync finished")

	def pullfile(self):

		ldp = len(Parms.datapaths)

		if ldp:

			if ldp > 1:	# alespoň 2 argumenty: poslední arg je destination dir, ostatní args jsou požadavky

				self._orig = Parms.datapaths[:ldp-1]

				self._dest = Parms.datapaths[-1]

			else:		# jedinný arg je požadavek, destination dir podle env DEST

				self._orig = Parms.datapaths[:1]

				self._dest = Parms.dest

		else:			# bez argumentů: požadavek i destinace podle env

			self._orig = Parms.orig

			self._dest = Parms.dest

		if not self._orig:

			self.d.abend("no filename specified, ABEND")

		else:

			self._node = Node(self.d, conn=True)

			size, fnum, dnum = (0, 0, 0)

			for orig in self._orig:		# zjistíme celkovou velikost dávky pro průběžné sledování

				orig = os.path.normpath(orig)

				self._node.putcmd("RECKON")

				self._node.putstr(orig)

				size += self._node.getnum()

				fnum += self._node.getnum()

				dnum += self._node.getnum()

			self.longtask()

			self.d.log("pulling {} bytes in {} files and {} dirs...".format(size, fnum, dnum), sev=3)

			self._counter = Counter(self.d, size)

			for orig in self._orig:		# vlastní download dávky

				orig = os.path.normpath(orig)

				self._node.putcmd("PULLFILE")

				if self.d.ll(4): self.d.log("pull of '{}' starting...".format(orig))

				self._node.putstr(orig)

				fn = self._node.getfn()

				while len(fn) > 0:

					fp = os.path.join(self._dest, fn)

					size = self._node.getnum()

					timestamp = self._node.getnum()

					if self.d.ll(4): self.d.log("pull to '{}, dir={}'...".format(fp, size == -1))

					if size < 0:

						self._node.receive_dir(fp, size, timestamp)

					else:

						self._node.receive_file(fp, size, timestamp, counter=self._counter)

					fn = self._node.getfn()

			self._counter.stop()

			if self.d.ll(2): self.d.log("pull file end")

	def pulllist(self):

		"""

		po odeslání příkazu se načítají údaje o souborech ve tvaru

			<délka_fn><fn><file_size><file_timestamp>

		"""

		self._node = Node(self.d, conn=True)

		self._node.putcmd("PULLLIST")

		self._node.putstr(os.path.normpath(self._orig[0] if self._orig else "."))

		fn = self._node.getfn()

		while fn:

			size = self._node.getnum()

			timestamp = time.asctime(time.localtime(self._node.getnum()))

			print("{: 12d} {:24} {}".format(size, timestamp, fn))

			fn = self._node.getfn()

			if self.d.ll(5): self.d.log("fn='{}'".format(str(fn)))

	def pushpeer(self):

		if not self._orig:

			self.d.abendMsg("nothing specified")

		elif not any(os.path.exists(p) for p in self._orig):

			self.d.abendMsg("{} not found".format(self._orig))

		else:

			self._node = Node(self.d, conn=True, peering=True)

			size = self.batchSize()

			self.sendBatchSize(size)	# poskytneme partnerovi údaje o velikosti odesílané dávky

			self._counter = Counter(self.d, size)

			try:

				for fp in self._orig:

					if self.d.ll(3): self.d.log("pushpeer: from={}".format(fp))

					if os.path.exists(fp):

						normfp = os.path.normpath(fp)

						self.pushpeer_recurse(normfp, os.path.dirname(normfp))

					else:

						self.d.warn("'{}' not found".format(fp))

			finally:

				self._node.sendEOD()  # end of batch

				self._counter.stop()

	def pushpeer_recurse(self, fp, prefix):

		if self.d.ll(4): self.d.log("pushpeer recurse: fp={}, relative fp={}".format(fp, os.path.relpath(fp, prefix)))

		if os.path.isdir(fp):

			for cwd, void, entries in os.walk(fp, topdown=True):

				for entry in entries:

					self.pushpeer_recurse(os.path.join(cwd, entry), prefix)

				self._node.putfileinfo(cwd, os.path.relpath(cwd, prefix))

			self._node.putfileinfo(fp, os.path.relpath(fp, prefix))

		else:

			self._node.putfileinfo(fp, os.path.relpath(fp, prefix))

			with open(fp, mode='rb') as f:

				g = self._node.genput()

				g.send(None)

				data = f.read(Parms.bufSize)

				while data:

					self._counter.update(len(data))

					try:

						g.send(data)

						data = f.read(Parms.bufSize)

					except Exception:

						break

				g.close()

		if self.d.ll(4): self.d.log("PUSHPEER: entry {} sent".format(fp))

	def sendBatchSize(self, size):

		"""

		odeslání informace o velikosti připravené dávky dat

		informace se odešle formou informace o souboru (filename, filesize, timestamp)

		"""

		if self.d.ll(4): self.d.log("sending batch size to peer...")

		self._node.putstr("dummy fn for batch size")

		self._node.putnum(size)

		self._node.putnum(0)

	def pullpeer(self):

		if not Parms.bindhost:

			self.d.abend("local host addr for peering not specified", None)

		try:

			self._node = Node(self.d, host=Parms.bindhost, tryPort=True, conn=False, peering=True)

		except Node.AllPortsBusy as e:

			self.d.abend("all predefined net ports are busy", None)

		try:

			self.d.log("accepting...", sev=4)

			accepted = self._node.acc(acc_TO=Parms.peer_accept_timeout)

			self.d.log("peer {}accepted".format("not " if not accepted else ""), sev=4)

			if not accepted: return

		except Exception as e:

			self._node.close_ssc()

			self.d.abend("peer pull accept", None)

			return

		finally:

			self._node.UDPsignalHUP()		# stop UDP broadcast

		self.d.log("get batch size from peer (dummy fn)", sev=4)

		self._node.getfn()	# dummy fn in batch size info

		batchsize = self._node.getnum()

		self.d.log("batchsize={}".format(batchsize), sev=4)

		self._node.getnum()	# dummy timestamp

		counter = Counter(self.d, batchsize)

		fn = self._node.getfn()

		while fn:	# receive batch of file/dir objects

			self.d.log("fn={}".format(fn), sev=4)

			fp = os.path.join(self._dest, fn)

			size = self._node.getnum()

			timestamp = self._node.getnum()

			if self.d.ll(4): self.d.log("pulling from peer to '{}'...".format(fp))

			if size < 0:

				if not self._node.receive_dir(fp, size, timestamp):

					self._node.close_sc()

			else:

				self._node.receive_file(fp, size, timestamp, counter=counter)

			fn = self._node.getfn()

		counter.stop()

		self._node.close_sc()

		self._node.close_ssc()

	def close_sc(self):

		self._node.close_sc()

	def dirsize(self, fp):

		p = subprocess.Popen(("du", "-sb", fp), stdout=subprocess.PIPE)

		p.wait()

		return int(p.stdout.readlines()[0].decode().split("\t")[0]) if p.returncode == 0 else -1

	def batchSize(self):

		size = 0

		for fp in self._orig:

			if os.path.exists(fp):

				size += self.dirsize(fp) if os.path.isdir(fp) else os.path.getsize(fp)

		return size

	def srv_hack(self):

		self._node = Node(self.d, conn=True)

		for orig in self._orig:

			self._node.putcmd("RECKON")

			self._node.putstr(orig)

			wholesize = self._node.getnum()

			fnum = self._node.getnum()

			dnum = self._node.getnum()

			self.d.log("reckon: {}, {}, {}".format(wholesize, fnum, dnum))

	def hack(self):

		self._node = Node(self.d, conn=False, tryPort=False, port=1111, host='10.0.1.47')

		self._node.acc(1)

	def hack_recurse(self, realfp, pref):

		self.d.log("hack realfp={}, relfp={}".format(realfp, os.path.relpath(realfp, pref)))

		if os.path.isdir(realfp):

			for cwd, void, entries in os.walk(realfp, topdown=True):

				for entry in entries:

					self.hack_recurse2(os.path.join(cwd, entry), pref)

				self.d.log("node.putfileinfo({}, {})".format(cwd, os.path.relpath(cwd, pref)))

			self.d.log("node.putfileinfo({}, {})".format(realfp, os.path.relpath(realfp, pref)))

		else:

			self.d.log("file {} processing".format(realfp))