import asyncio
from datetime import datetime
from sqlalchemy.types import Enum
from sqlalchemy import Column, DateTime, ForeignKey
# from sqlalchemy.orm.attributes import flag_modified
from sqlalchemy import Enum
import enum
from base.orm import Base, local_session
from orm.topic import ShoutTopic

class ReactionKind(enum.Enum):
	AGREE 	= 1 # +1
	DISAGREE = 2 # -1
	PROOF 	= 3	# +1
	DISPROOF = 4 # -1
	ASK		= 5 # +0 bookmark
	PROPOSE	= 6 # +0
	QUOTE	= 7 # +0 bookmark
	COMMENT	= 8 # +0
	ACCEPT	= 9 # +1
	REJECT	= 0 # -1
	LIKE	= 11 # +1
	DISLIKE	= 12 # -1
	# TYPE = <reaction index> # rating diff

def kind_to_rate(kind) -> int:
	if kind in [
		ReactionKind.AGREE,
		ReactionKind.LIKE,
		ReactionKind.PROOF,
		ReactionKind.ACCEPT
	]: return 1
	elif kind in [
		ReactionKind.DISAGREE,
		ReactionKind.DISLIKE,
		ReactionKind.DISPROOF,
		ReactionKind.REJECT
	]: return -1
	else: return 0
class ReactedByDay(Base):
	__tablename__ = "reacted_by_day"

	id = None
	reaction = Column(ForeignKey("reaction.id"), primary_key = True)
	shout = Column(ForeignKey('shout.slug'), primary_key=True)
	replyTo = Column(ForeignKey('reaction.id'), nullable=True)
	kind: int = Column(Enum(ReactionKind), nullable=False, comment="Reaction kind")
	day = Column(DateTime, primary_key=True, default=datetime.now)

class ReactedStorage:
	reacted = {
		'shouts': {},
		'topics': {},
		'reactions': {}
	}
	rating = {
		'shouts': {},
		'topics': {},
		'reactions': {}
	}
	reactions = []
	to_flush = []
	period = 30*60  # sec
	lock = asyncio.Lock()

	@staticmethod
	def init(session):
		self = ReactedStorage
		all_reactions = session.query(ReactedByDay).all()
		print('[stat.reacted] %d reactions total' % len(all_reactions))
		for reaction in all_reactions:
			shout = reaction.shout
			topics = session.query(ShoutTopic.topic).where(ShoutTopic.shout == shout).all()
			kind = reaction.kind
   
			self.reacted['shouts'][shout] = self.reacted['shouts'].get(shout, [])
			self.reacted['shouts'][shout].append(reaction)
			self.rating['shouts'][shout] = self.rating['shouts'].get(shout, 0) + kind_to_rate(kind)
   
			for t in topics:
				self.reacted['topics'][t] = self.reacted['topics'].get(t, [])
				self.reacted['topics'][t].append(reaction)
				self.rating['topics'][t] = self.rating['topics'].get(t, 0) + kind_to_rate(kind) # rating
	
			if reaction.replyTo:
				self.reacted['reactions'][reaction.replyTo] = self.reacted['reactions'].get(reaction.replyTo, [])
				self.reacted['reactions'][reaction.replyTo].append(reaction)
				self.rating['reactions'][reaction.replyTo] = self.rating['reactions'].get(reaction.replyTo, 0) + kind_to_rate(reaction.kind)
		ttt = self.reacted['topics'].values()
		print('[stat.reacted] %d topics reacted' % len(ttt))
		print('[stat.reacted] %d shouts reacted' % len(self.reacted['shouts']))
		print('[stat.reacted] %d reactions reacted' % len(self.reacted['reactions']))

	@staticmethod
	async def get_shout(shout_slug):
		self = ReactedStorage
		async with self.lock:
			return self.reacted['shouts'].get(shout_slug, [])
	
	@staticmethod
	async def get_topic(topic_slug):
		self = ReactedStorage
		async with self.lock:
			return self.reacted['topics'].get(topic_slug, [])

	@staticmethod
	async def get_reaction(reaction_id):
		self = ReactedStorage
		async with self.lock:
			return self.reacted['reactions'].get(reaction_id, [])

	@staticmethod
	async def get_rating(shout_slug):
		self = ReactedStorage
		rating = 0
		async with self.lock:
			for r in self.reacted['shouts'].get(shout_slug, []):
				rating = rating + kind_to_rate(r.kind)
		return rating

	@staticmethod
	async def get_topic_rating(topic_slug):
		self = ReactedStorage
		rating = 0
		async with self.lock:
			for r in self.reacted['topics'].get(topic_slug, []):
				rating = rating + kind_to_rate(r.kind)
		return rating

	@staticmethod
	async def get_reaction_rating(reaction_id):
		self = ReactedStorage
		rating = 0
		async with self.lock:
			for r in self.reacted['reactions'].get(reaction_id, []):
				rating = rating + kind_to_rate(r.kind)
		return rating

	@staticmethod
	async def increment(shout_slug, kind, reply_id = None):
		self = ReactedStorage
		reaction: ReactedByDay = None
		async with self.lock:
			with local_session() as session:
				reaction = ReactedByDay.create(shout=shout_slug, kind=kind, reply=reply_id)
				self.reacted['shouts'][shout_slug] = self.reacted['shouts'].get(shout_slug, [])
				self.reacted['shouts'][shout_slug].append(reaction)
				if reply_id:
					self.reacted['reaction'][reply_id] = self.reacted['reactions'].get(shout_slug, [])
					self.reacted['reaction'][reply_id].append(reaction)
					self.rating['reactions'][reply_id] = self.rating['reactions'].get(reply_id, 0) + kind_to_rate(kind)
				else:
					self.rating['shouts'][shout_slug] = self.rating['shouts'].get(shout_slug, 0) + kind_to_rate(kind)