import collections

import socket

import logging as log

from datetime import datetime

import config as conf

from hashtree import HashTree

from networkers import NetworkReader,NetworkWriter

class Connection:

	def __init__(self):

			outcoming.writeMsg(jsonData)

			jsonData,binData=incoming.readMsg()

			assert jsonData["command"]=="ack"

			# determine which blocks to send

			print(datetime.now(), "negotiating:")

			while len(nodeStack)>0:

				i=nodeStack.pop()

				outcoming.writeMsg({"command":"req", "index":i})

				jsonData,binData=incoming.readMsg()

				assert jsonData["index"]==i

				if localTree.store[i]!=binData:

					if 2*i+3<len(localTree.store): # inner node

						nodeStack.append(2*i+2)

						nodeStack.append(2*i+1)

					else:

						blocksToTransfer.append(i-localTree.leafStart) # leaf

		return blocksToTransfer

	def sendData(self,blocksToTransfer):

		log.info(blocksToTransfer)

		dataFile=open(self.filename,mode="rb")

		i1=-1

		print(datetime.now(), "sending data:")

		with Connection() as (incoming,outcoming):

			for (k,i2) in enumerate(blocksToTransfer):

				jsonData={"command":"send", "index":i2, "dataType":"data"}

				if i1+1!=i2:

					dataFile.seek(i2*HashTree.BLOCK_SIZE)

				binData=dataFile.read(HashTree.BLOCK_SIZE)

				log.info("block #{0}: {1}...{2}".format(i2,binData[:5],binData[-5:]))

				outcoming.writeMsg(jsonData,binData)

				jsonData,binData=incoming.readMsg()

				assert jsonData["command"]=="ack" and jsonData["index"]==i2, jsonData

				i1=i2

		with Connection() as (incoming,outcoming):

			outcoming.writeMsg({"command":"end"})

		log.info("closing session...")

		dataFile.close()

import hashlib

import os

from datetime import datetime

class HashTree:

	HASH_LEN=16 # bytes

	BLOCK_SIZE=4096 # bytes

			stat=os.fstat(f.fileno())

			size=stat.st_size # !! symlinks

			leafCount=(size-1)//HashTree.BLOCK_SIZE+1 # number of leaf blocks

			res=cls(leafCount)

			print(datetime.now(), "hashing file:")

			for i in range(leafCount):

				data=f.read(HashTree.BLOCK_SIZE)

				res.insertLeaf(hashlib.sha256(data).digest()[HashTree.HASH_LEN:])

		res.buildTree()

		return res

	@classmethod

	def load(cls,filename):

			self.store[index]=hashlib.sha256(self.store[index*2+1]+self.store[index*2+2]).digest()[HashTree.HASH_LEN:]

			index=(index-1)//2

	## Fast construction of the tree over the leaves. O(n).

	def buildTree(self):

		print(datetime.now(), "building tree:")

		for i in range(self.leafStart-1,-1,-1):

			self.store[i]=hashlib.sha256(self.store[i*2+1]+self.store[i*2+2]).digest()[HashTree.HASH_LEN:]

if __name__=="__main__":

	f1=HashTree.fromFile(open("serverFile.txt",mode='rb'))

	f2=HashTree.fromFile(open("clientFile.txt",mode='rb'))