import datetime
import random
import numpy as np
import matplotlib.pyplot as plt

# sudo apt-get install python-tk
# pip2 install numpy matplotlib

def create_block(timestamp, num_pow):
	return {'time_stamp' : timestamp, 'num_pow' : num_pow, 'first_work_factor':0}

def create_work(idx, factor, target):
	return {'id': idx, 'base_executions_per_second' : factor, 'target' : target}

def addSecs(tm, secs):
    fulldate = tm + datetime.timedelta(seconds=secs)
    return fulldate

def randomDuration():
	if do_not_randomize_block_times_but_do_always_60_sec:
		return 60
	else:
		return int(random.uniform(25, 120))

current_time = datetime.datetime.now()

# experiment with the number of work packages
works_to_create = 3

generate_blocks = 100
current_height = 0
blockchain = []
work_packages = []
base_target = 0x000000ffffffffffffffffffffffffff
poisson_distribution = np.random.poisson(5, generate_blocks)
stretch_number_pows = True
do_not_randomize_block_times_but_do_always_60_sec = False
new_miner_every_xth_second = 10
how_many_miners_come_or_go = 70242
initial_miners = 199381

def currently_active_miners(current_height):
	# get the current active number of miners in relation of blockchain height,
	# but the number of miners increases by 1 every 10 blocks
	increases = int(current_height/new_miner_every_xth_second) * how_many_miners_come_or_go
	return initial_miners+increases

	# for now, leave poisson distributed variable miner count out and assume only one miner
	ret = poisson_distribution[current_height]
	if ret > 0:
		return ret
	else:
		return 1

def miner_pows_based_on_target(work, height, dur):
	current_target = work["target"]
	factor = (current_target / base_target) * 1.0*dur/60.0
	actual_pow_mined = work["base_executions_per_second"]
	# random jitter
	actual_pow_mined = abs((actual_pow_mined - 1) + random.uniform(1,2)) * currently_active_miners(height)
	actual_pow_mined = actual_pow_mined *factor
	# rate limit to 20 pows per block
        if actual_pow_mined > 20:
            actual_pow_mined = 20
	if actual_pow_mined < 0:
		actual_pow_mined = 0
	if actual_pow_mined == 0:
		print "mined",actual_pow_mined,work["base_executions_per_second"]*factor,currently_active_miners(height)
	return actual_pow_mined
def kimoto(x):
    return  1 + (0.7084 * pow(((x)/(144)), -1.228));
def retarget_work(block, x):
    targetI = x["target"]
    pastMass = 0
    counter = 0
    current_block = block
    current_block_timestamp = blockchain[current_block]["time_stamp"]
    adjustment = 0
    isFull = True
    fullCnt = 0
    isEmpty = True
    emptyCnt = 0
    while isFull or isEmpty:
        if isFull and blockchain[current_block]["num_pow"][x["id"]] == 20:
            fullCnt += 1
        else:
            isFull = False
        if isEmpty and blockchain[current_block]["num_pow"][x["id"]] == 0:
            emptyCnt += 1
        else:
            isEmpty = False
        current_block -= 1
        if current_block < 1:
            break
    current_block = block
    while True:
        counter += 1
        pastMass += blockchain[current_block]["num_pow"][x["id"]]
        seconds_passed = (current_block_timestamp - blockchain[current_block-1]["time_stamp"]).seconds
        current_block -= 1
        if seconds_passed < 1:
            seconds_passed = 1
        trs_per_second = float(pastMass) / float(seconds_passed)
        target_per_second = 10.0 / 60.0
        adjustment = target_per_second / trs_per_second
        kim = kimoto(pastMass * 30)
        #print("kim : " + str(kim) + " adjustment : " + str(adjustment))
        if adjustment > kim or adjustment < (1.0/kim):
            break
        if current_block < 1:
            break
    if fullCnt > 1:
        adjustment = adjustment / (1 << (fullCnt))
    if emptuCnt > 1:
        adjustment = adjustment * (1 << (emptyCnt))
    targetI = targetI * adjustment
    if targetI>base_target:
            targetI = base_target
    if x["id"] == 0:
            blockchain[block]["first_work_factor"] = adjustment
    x["target"] = targetI


def retarget_works(block):
	for x in work_packages:
		retarget_work(block,x)

# Here we create up to three different work objects
if works_to_create>=1:
	work_packages.append(create_work(0, 20, base_target))
if works_to_create>=2:
	work_packages.append(create_work(1, 60, base_target))
if works_to_create>=3:
	work_packages.append(create_work(2, 35, base_target))

while current_height < generate_blocks:
	dur = randomDuration()
	current_time = addSecs(current_time,dur) # random block generation time
	block_pows = {}
	for x in work_packages:
		num_pow = miner_pows_based_on_target(x, current_height, dur) # mine some POW depending on the current difficulty
		block_pows[x["id"]] = num_pow
	blockchain.append(create_block(current_time, block_pows))
	retarget_works(current_height) # This retargeting method is the "critical part here"
	current_height = current_height + 1


values = []
target_factors = []
ideal = []
for idx in range(len(blockchain)):
	if idx == 0:
		continue
	x = blockchain[idx]
	x_minus_one = blockchain[idx-1]
	time_passed = (x["time_stamp"] - x_minus_one["time_stamp"]).seconds
	strech_normalizer = time_passed / 60.0
	if stretch_number_pows == False:
		ideal.append(works_to_create*10*strech_normalizer)
	else:
		ideal.append(works_to_create*10)
	sum_x = 0
	for y in x["num_pow"]:
		sum_x += x["num_pow"][y]
	if stretch_number_pows == False:
		values.append(sum_x)
	else:
		values.append(sum_x/strech_normalizer)
x = range(generate_blocks)[1:]
y = values

#fig = plt.figure()
ax0 = plt.subplot(211)
if stretch_number_pows:
	ax0.set_ylabel('POW rate per 60s', color='b')
else:
	ax0.set_ylabel('POWs per Block', color='b')
ax0.set_xlabel('Block height')
ax0.plot(x,y,'-o',x,ideal,'r--')
values = []
ideal = []
target_factors = []
for idx in range(len(blockchain)):
	if idx == 0:
		continue
	x = blockchain[idx]
	x_minus_one = blockchain[idx-1]
	time_passed = (x["time_stamp"] - x_minus_one["time_stamp"]).seconds
	strech_normalizer = time_passed / 60.0
	if stretch_number_pows == False:
		ideal.append(10*strech_normalizer)
	else:
		ideal.append(10)
	sum_x = 0
	sum_x += x["num_pow"][0]
	#print "sumx",sum_x
	if stretch_number_pows == False:
		values.append(sum_x)
	else:
		values.append(sum_x/strech_normalizer)
x = range(generate_blocks)[1:]
y = values
plt.title('All Works: Total POWs')

ax1 = plt.subplot(212)
ax1.plot(x,y,'-o',x,ideal,'r--')
ax1.set_xlabel('Block Height')
# Make the y-axis label and tick labels match the line color.
if stretch_number_pows:
	ax1.set_ylabel('POW rate per 60s', color='b')
else:
	ax1.set_ylabel('POWs per Block', color='b')

for tl in ax1.get_yticklabels():
    tl.set_color('b')



ax2 = ax1.twinx()
ax2.set_ylim(0.4, 1.6)
ax2.bar(x,[x["first_work_factor"] for x in blockchain][1:],0.45,color='#deb0b0', alpha=0.2)
ax2.set_ylabel('Retargeting Factor', color='r')
for tl in ax2.get_yticklabels():
    tl.set_color('r')
plt.title('First Work: POWs + Retargeting Factor')

plt.show()

def retarget_work_2(block, x):
    targetI = x["target"]
    pastMass = 0
    counter = 0
    current_block = block
    current_block_timestamp = blockchain[current_block]["time_stamp"]
    adjustment = 0
    while True:
        counter += 1
        pastMass += blockchain[current_block]["num_pow"][x["id"]]
        seconds_passed = (current_block_timestamp - blockchain[current_block-1]["time_stamp"]).seconds
        current_block -= 1
        if seconds_passed < 1:
            seconds_passed = 1
        trs_per_second = float(pastMass) / float(seconds_passed)
        target_per_second = 10.0 / 60.0
        adjustment = target_per_second / trs_per_second
        kim = kimoto(pastMass * 30)
        #print("kim : " + str(kim) + " adjustment : " + str(adjustment))
        if adjustment > kim or adjustment < (1.0/kim):
            print("kim : " + str(kim) + " 1/kim : " + str(1.0/kim) + " adj : " + str(adjustment))
            break
        if current_block < 1:
            break
    targetI = targetI * adjustment
    if targetI>base_target:
            targetI = base_target
    if x["id"] == 0:
            blockchain[block]["first_work_factor"] = adjustment
    x["target"] = targetI