coding utf-8 import logging import datetime from mongoengine import Do

# -*- coding: utf-8 -*-
import logging
import datetime

from mongoengine import Document
from mongoengine.queryset import queryset_manager
from mongoengine.fields import (StringField, DateTimeField, BooleanField, IntField)

from utils.mongoengine_pagination import Pagination
from utils.secure_cookies import CryptoSessionCookies
from conf.config import SECRET_KEY


logger = logging.getLogger(__name__)


class Player(Document):
	"""
	MongoDB model to store users login information

	player_id - unique ID for player generate_hash(name, device_id)
	"""

	meta = {
		'collection': 'players',
		'indexes': ['-created_at', 'device_id', 'ready_to_play'],
	}


	player_id = StringField()
	name = StringField(max_length=30)
	device_id = StringField(max_length=80)

	active = BooleanField(default=True)
	ready_to_play = BooleanField(default=False)
	playing = BooleanField(default=False)

	cookie = StringField()

	wins = IntField(default=0)
	loses = IntField(default=0)
	runaways = IntField(default=0)  # when player shotdown or close application during play

	created_at = DateTimeField(default=datetime.datetime.now)


	@queryset_manager
	def pagination(doc_cls, queryset, page, per_page):
		return Pagination(queryset, page, per_page)


	@staticmethod
	def generate_player_hash(name, device_id):
		data = {
			'name': name,
			'device_id': device_id,
		}
		return CryptoSessionCookies(SECRET_KEY).crypt(data)

	def check_player_hash(self, name, device_id):
		data = {
			'name': name,
			'device_id': device_id,
		}
		data = CryptoSessionCookies(SECRET_KEY).decrypt(data)
		if (data['name'] == self.name) and (data['device_id'] == self.device_id):
			return True
		else:
			return False

	def init_player(self, active=True, ready_to_play=False, **kwargs):
		# save uniq player id
		data = {
			'name': self.name,
			'device_id': self.device_id,
		}
		self.player_id = CryptoSessionCookies(SECRET_KEY).crypt(data)

		self.active = active
		self.ready_to_play = ready_to_play

	def generate_access_token(self):
		return CryptoSessionCookies(SECRET_KEY).crypt(self.device_id + self.name + SECRET_KEY)

	@staticmethod
	def authenticate(player_id, access_token):
		player_doc = Player.objects(player_id=player_id).first()
		if player_doc is not None:
			if player_doc.generate_access_token() == access_token:
				return player_doc
		return None

	@staticmethod
	def add_player(name, device_id):
		player_doc = Player.objects(name=name, device_id=device_id).first()
		if player_doc is None:
			player_doc = Player(name=name, device_id=device_id)
			player_doc.init_player()
			player_doc.save()
			return player_doc
		return None

	def is_active(self):
		return self.active

	def is_ready(self):
		return self.ready_to_play

	def __unicode__(self):
		return u'<Player: %s %s>' % (self.name, self.device_id)