import sys

import os.path

from argparse import ArgumentParser

from hashtree import HashTree

from client import Client

from server import Server

		sys.exit(1)

def buildTree(args):

	tree=HashTree.fromFile(args.datafile)

	tree.save(args.treefile)

def update(args):

	c=Client(args.datafile)

	blocksToTransfer=c.negotiate()

	c.sendData(blocksToTransfer)

def serve(args):

	# debug copy default file

	import shutil

	origFilename=args.datafile

	filename=origFilename+"_"

	shutil.copyfile(origFilename,filename)

	s.serve()

parser=ArgumentParser()

subparsers=parser.add_subparsers()

pRebuild=subparsers.add_parser("build")

pRebuild.add_argument("treefile",help="stored hash tree location")

pRebuild.add_argument("datafile")

pRebuild.set_defaults(func=buildTree)

pUpdate=subparsers.add_parser("update")

pUpdate.add_argument("-p","--port",type=int)

pUpdate.add_argument("--host",default="127.0.0.1")

pUpdate.add_argument("-t","--tree",help="stored hash tree location")

pUpdate.add_argument("datafile")

pUpdate.set_defaults(func=update)

pServe=subparsers.add_parser("serve")

pServe.add_argument("-p","--port",type=int)

pServe.add_argument("--host",default="")

pServe.add_argument("-t","--tree",help="stored hash tree location")

pServe.add_argument("datafile")

pServe.set_defaults(func=serve)

args=parser.parse_args()

args.func(args)

import socket

from hashtree import HashTree

from networkers import NetworkReader,NetworkWriter

import logging as log

import config as conf

class Connection:

	def __init__(self,server_socket):

		self.socket, address = server_socket.accept()

		log.info('Connected by {0}'.format(address))

		fr=self.socket.makefile(mode="rb")

		fw=self.socket.makefile(mode="wb")

		self.incoming=NetworkReader(fr)

		self.outcoming=NetworkWriter(fw)

	def __enter__(self):

		return self.incoming,self.outcoming

	def __exit__(self, exc_type, exc_val, exc_tb):

		self.socket.close()

class Server:

		self.filename=filename

		self.tree=HashTree.fromFile(filename)

		self.BLOCK_SIZE=self.tree.BLOCK_SIZE

		self.ss = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

		self.ss.bind(("",conf.port))

		self.ss.listen(1)

		self._lastWrite=-1

	def serve(self):

		while self._serveOne():

			pass

	def _serveOne(self):

		with Connection(self.ss) as (incoming,outcoming):

			jsonData,binData=incoming.readMsg()

			if jsonData["command"]=="init":

				assert jsonData["blockSize"]==self.BLOCK_SIZE

				assert jsonData["blockCount"]==self.tree.leafCount

			elif jsonData["command"]=="req":

				outcoming.writeMsg(*self._requestHash(jsonData))

			elif jsonData["command"]=="send" and jsonData["dataType"]=="data":

				self._receiveData(jsonData,binData)

			elif jsonData["command"]=="end":

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

				return False

			else:

				assert False, jsonData["command"]

			return True

	def _requestHash(self,jsonData):

		log.info("received request for node #{0}".format(jsonData["index"]))

		assert jsonData["index"]<len(self.tree.store)

		nodeHash=self.tree.store[jsonData["index"]]

		jsonResponse={"command":"send", "index":jsonData["index"], "dataType":"hash"}

		binResponse=nodeHash

		return (jsonResponse,binResponse)

	def _receiveData(self,jsonData,binData):

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

		i=jsonData["index"]

			if self._lastWrite+1!=i:

		self._lastWrite=i

		# never update the hash tree