from otree.api import Currency as c, currency_range
from . import views
from ._builtin import Bot
from .models import Constants


class PlayerBot(Bot):

    def play_round(self):
        yield (views.Welcome)
        yield (views.IntroPage)
        yield (views.Results)
### Tests
'''
import os, sys, numpy, pandas as pd, random, time 
from collections import Counter
sys.path.insert(0, 'memory_experimentSP/')
from create_events import create_news, Draws


class Constants():
	name_in_url = 'memory_experimentSP'
	players_per_group = None
	num_rounds = 1
	NEWS_DIR = 'memory_experimentSP/static/memory_experimentSP/'
	facts = pd.read_csv(NEWS_DIR + 'facts.csv')
	fact_positivity = dict(zip(facts.FACTID, facts.FACTTYPE))
	newspapers = {
			'Regulation': 'Regulation-Products;Finance-Regulation', 
			'Product': 'Finance-Products;Regulation-Products',
			'Finance': 'Finance-Products;Finance-Regulation',
			 }
	fact_set = facts.RECALL.unique().tolist()
	# factid is
	recall2id = {t: (ind*2)+1 for ind, t in enumerate(fact_set)}
	# Change to adjust number of pages, facts per page, and news timout
	num_pages = 3
	num_facts_per_page = 3
	news_timeout = 90
	s = 2
	news_bias = 0.60

newspaper_list = list(Constants.newspapers.keys())
N = 1000

# Positive Event generation
thresholds = []
for n in range(N):
	news_raw = create_news(Constants, 1, 0.7)
	temp = []
	for val in news_raw.values():
		for v in val.values():
			temp.extend(v)
	scores = Counter([Constants.fact_positivity[t] for t in temp])
	thresholds.append(scores[1]/len(temp))

numpy.average(thresholds)
# Negative Event Generation
thresholds2 = []
for n in range(N):
	news_raw = create_news(Constants, -1)
	temp = []
	for val in news_raw.values():
		for v in val.values():
			temp.extend(v)
	scores = Counter([Constants.fact_positivity[t] for t in temp])
	thresholds2.append(scores[-1]/len(temp))

# Test News Generation for each type
all_events = []
for play in range(10000):
	draw_type = numpy.random.choice(10, p=[0.2, 0.1, 0.1, 0.1, 0.075, 0.075, 0.075, 0.1, 0.1, 0.075])
	drawer = Draws(np_list = newspaper_list, news = news_raw, newspapers = Constants.newspapers)
	events = drawer.draw_helper(draw_type)
	all_events.append(len(set(events[0]).union(set(events[1])).union(set(events[2]))))

for draw_type in range(10):
	for n in range(N):
		if n % 2 == 0: 
			news_raw = create_news(Constants, -1)
		else:
			news_raw = create_news(Constants, 1)
		random.shuffle(newspaper_list)
		drawer = Draws(np_list = newspaper_list, news = news_raw, newspapers = Constants.newspapers)
		events = drawer.draw_helper(draw_type)
		if draw_type == 0:
			assert len(set(events[0]).intersection(set(events[1]))) == 0
			assert len(set(events[0]).intersection(set(events[2]))) == 0
			assert len(set(events[1]).intersection(set(events[2]))) == 0
			print('passed draw_type: %s trial: %s' %(draw_type, n))
		elif draw_type == 1:
			assert len(set(events[0]).intersection(set(events[1]))) == 1
			assert len(set(events[0]).intersection(set(events[2]))) == 0
			assert len(set(events[1]).intersection(set(events[2]))) == 0
			print('passed draw_type: %s trial: %s' %(draw_type, n))
		elif draw_type == 2:
			assert len(set(events[1]).intersection(set(events[2]))) == 1
			assert len(set(events[0]).intersection(set(events[1]))) == 0
			assert len(set(events[0]).intersection(set(events[2]))) == 0
			print('passed draw_type: %s trial: %s' %(draw_type, n))
		elif draw_type == 3:
			assert len(set(events[0]).intersection(set(events[2]))) == 1
			assert len(set(events[0]).intersection(set(events[1]))) == 0
			assert len(set(events[1]).intersection(set(events[2]))) == 0
			print('passed draw_type: %s trial: %s' %(draw_type, n))
		elif draw_type == 4:
			assert len(set(events[0]).intersection(set(events[1]))) == 2
			assert len(set(events[0]).intersection(set(events[2]))) == 0
			assert len(set(events[1]).intersection(set(events[2]))) == 0
			print('passed draw_type: %s trial: %s' %(draw_type, n))
		elif draw_type == 5:
			assert len(set(events[1]).intersection(set(events[2]))) == 2
			assert len(set(events[0]).intersection(set(events[1]))) == 0
			assert len(set(events[0]).intersection(set(events[2]))) == 0
			print('passed draw_type: %s trial: %s' %(draw_type, n))
		elif draw_type == 6:
			assert len(set(events[0]).intersection(set(events[2]))) == 2
			assert len(set(events[0]).intersection(set(events[1]))) == 0
			assert len(set(events[1]).intersection(set(events[2]))) == 0
			print('passed draw_type: %s trial: %s' %(draw_type, n))
		elif draw_type == 7:
			assert len(set(events[0]).intersection(set(events[1]))) == 1
			assert len(set(events[0]).intersection(set(events[2]))) == 1
			assert len(set(events[1]).intersection(set(events[2]))) == 0
			print('passed draw_type: %s trial: %s' %(draw_type, n))
		elif draw_type == 8:
			assert len(set(events[0]).intersection(set(events[1]))) == 1
			assert len(set(events[1]).intersection(set(events[2]))) == 1
			assert len(set(events[0]).intersection(set(events[2]))) == 0
			print('passed draw_type: %s trial: %s' %(draw_type, n))
		elif draw_type == 9:
			assert len(set(events[0]).intersection(set(events[2]))) == 1
			assert len(set(events[1]).intersection(set(events[2]))) == 1
			assert len(set(events[0]).intersection(set(events[1]))) == 0
			print('passed draw_type: %s trial: %s' %(draw_type, n))

print('Positive Events/Total Events with good company out of sample size %s: %s' % (N, numpy.average(thresholds)))
print('Negative Events/Total Events with bad company out of sample size %s: %s' % (N, numpy.average(thresholds2)))
print('Passed all news tests out of %s samples per draw type' % N)

class Player():
	pass

all_facts = []
for n in range(N):
	plyr = Player()
	facts_copy = Constants.facts.copy()
	plyr.P = int(random.uniform(0, 100))
	plyr.unique_code = uuid.uuid4()
	# Randomly order newspapers 
	newspaper_list = list(Constants.newspapers.keys())
	random.shuffle(newspaper_list)
	plyr.company_type = random.choice([-1,1])
	news_raw = create_news(Constants, plyr.company_type)
	drawer = Draws(np_list = newspaper_list, news = news_raw, newspapers = Constants.newspapers)
	plyr.draw_type = numpy.random.choice(10, p=[0.2, 0.1, 0.1, 0.1, 0.075, 0.075, 0.075, 0.1, 0.1, 0.075])
	events = drawer.draw_helper(plyr.draw_type)
	plyr.seen_events = str([item for sublist in events.values() for item in sublist]).replace('[', '').replace(']', '')  
	plyr.np_order = '; '.join(newspaper_list)
	plyr.num_positive_facts = 0
	plyr.num_negative_facts = 0
	seen_facts = []
	b = []
	for pagenum,newsp in enumerate(newspaper_list):
		# Pick one from each version
		news_hold = []
		for factid in events[pagenum]:
			if Constants.fact_positivity[factid] == 1 and not factid in seen_facts:
				plyr.num_positive_facts = plyr.num_positive_facts + 1
			elif not factid in seen_facts:
				plyr.num_negative_facts = plyr.num_negative_facts + 1
			seen_facts.append(factid)
			content_index = random.choice(facts_copy[facts_copy.FACTID == factid].index)
			news_hold.append(str(facts_copy.loc[content_index, 'CONTENT']))
			facts_copy = facts_copy.drop(content_index)
		if plyr.num_negative_facts > plyr.num_positive_facts:
			plyr.positivity_balance = 'More Negative'
		elif plyr.num_negative_facts == plyr.num_positive_facts:
			plyr.positivity_balance = 'Equal Amount'
		else:
			plyr.positivity_balance = 'More Positive'
		b.extend(news_hold)
	a = len(set([item for sublist in events.values() for item in sublist]))
	all_facts.append(a)

'''