import json
from collections import defaultdict
from typing import List, Tuple

import matplotlib.pyplot as plt
import os

from analyzers import Store, BiogamesStore, SimulationOrderAnalyzer
from . import Render
from .. import Result, SimulationRoundsAnalyzer, BoardDurationAnalyzer, ActivityMapper

ONE_DAY = 24 * 60 * 60


def plot(src_data: List[Tuple[str, List[int]]], title: str = "simulation retries", ylabel: str = "simulation rounds",
		 xargs={}):
	names, datas = list(zip(*src_data))
	plt.boxplot(datas, labels=names, **xargs)
	plt.xticks(rotation='vertical')
	# plt.margins()
	plt.ylabel(ylabel)
	plt.title(title)
	plt.show()


def plot_old(src_data: List[Tuple[str, List[int]]], ylabel="simulation rounds", title="simulation retries",
			 rotation='vertical'):
	names, datas = list(zip(*src_data))
	plt.boxplot(datas, labels=names, **{"showfliers": True})
	plt.xticks(rotation=rotation)
	# plt.margins()
	plt.ylabel(ylabel)
	plt.title(title)
	plt.show()


class SimulationRoundsRender(Render):
	result_types = [SimulationRoundsAnalyzer]
	xargs = {}

	def render(self, results: List[Result]):
		data = defaultdict(list)
		for result in self.filter(results):
			get = result.get()
			for key in get:
				data[key].append(get[key])
		data_tuples = [(key, data[key]) for key in sorted(data)]
		data_tuples = sorted(data_tuples, key=lambda x: sum(x[1]))
		plot(data_tuples, xargs=self.xargs)

	result_types = [SimulationRoundsAnalyzer]


class SimulationRoundsMeanRender(SimulationRoundsRender):
	xargs = {"showfliers": False}


class BoardDurationHistRender(Render):
	result_types = [BoardDurationAnalyzer]

	def render(self, results: List[Result]):
		plt.title("board display duration")
		plt.xlabel("display time")
		plt.ylabel("# of boards")
		data = []
		for result in self.filter(results):
			session = result.get()
			_data = []
			for board in session:
				if "active" in board:
					value = board["active"]
					if value > ONE_DAY:
						_data.append(0)
					else:
						_data.append(value)
				else:
					_data.append(0)
			data.append(_data)
		n, bins, patches = plt.hist(data, log=True)
		plt.show()


class BoardDurationBoxRender(Render):
	result_types = [BoardDurationAnalyzer]

	def render(self, results: List[Result]):
		data = defaultdict(list)
		for result in self.filter(results):
			get = result.get()
			for board in get:
				duration = board['active'] if 'active' in board else 0
				if duration < ONE_DAY:
					data[board['id']].append(duration)
		data_tuples = [(key, data[key]) for key in sorted(data)]
		data_tuples = sorted(data_tuples, key=lambda x: sum(x[1]))
		plot(data_tuples, "board duration", "display time", xargs={"showfliers": False})


class ActivityMapperRender(Render):
	result_types = [ActivityMapper]

	def render(self, results: List[Result]):
		print(os.getcwd())
		for result in self.filter(results):
			data = result.get()
			with open(os.path.join("static", "progress", "data", data['instance']), "w") as out:
				json.dump(data["store"], out, indent=1)
		return "ok"


class StoreRender(Render):
	result_types = [Store, BiogamesStore]

	def render(self, results: List[Result]):
		for result in self.filter(results):
			with open(os.path.join("static", "progress", "data", "fooo"), "w") as out:
				json.dump(result.get(), out, indent=1)


class SimulationOrderRender(Render):
	def render(self, results: List[Result]):
		data = defaultdict(list)
		for result in self.filter(results):
			get = result.get()
			for i, value in enumerate(get):
				data[i].append(value)
		# data_tuples = [(key, data[key]) for key in sorted(data)]
		# data_tuples = sorted(data_tuples, key=lambda x: sum(x[1]))
		# plot(enumerate([r.get() for r in self.filter(results)]))
		plot_old(list(data.items()), ylabel="simulation retries", title="sequential simulation retries", rotation=None)

	result_types = [SimulationOrderAnalyzer]