from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

# All the Team related methods

# Python
from django.utils import timezone
from datetime import datetime
from datetime import timedelta
import time
from django.db import IntegrityError
import uuid
from django.conf import settings

from rowers.utils import myqueue

import django_rq
queue = django_rq.get_queue('default')
queuelow = django_rq.get_queue('low')
queuehigh = django_rq.get_queue('low')

from rowers.models import (
    Rower, Workout, Team, TeamInvite,User,TeamRequest, CoachRequest, CoachOffer,
    CoachingGroup
    )

from rowers.tasks import (
    handle_sendemail_invite,
    handle_sendemail_request,
    handle_sendemail_member_dropped,handle_sendemail_request_accept,
    handle_sendemail_request_reject,handle_sendemail_invite_reject,
    handle_sendemail_invite_accept,handle_sendemail_team_removed,
    handle_sendemail_coachrequest,handle_sendemail_coacheerequest,
    handle_sendemail_coachoffer_rejected,
    handle_sendemail_coachoffer_accepted,
    handle_sendemail_coachrequest_rejected,
    handle_sendemail_coachrequest_accepted,
    handle_sendemail_message,
    )

from rowers.models import ValidationError

# Low level functions - to be called by higher level methods

inviteduration = 14 # days

def handle_remove_workouts_team(ws,t):
    for w in ws:
        w.team.remove(t)

    return 1

def handle_add_workouts_team(ws,t):
    
    for w in ws:
        w.team.add(t)

    return 1

def update_team(t,name,manager,private,notes,viewing):
    if t.manager != manager:
        return (0,'You are not the manager of this team')
    try:
        t.name = name
        t.manager = manager
        t.private = private
        t.notes = notes
        t.viewing = viewing
        t.save()
    except IntegrityError:
        return (0,'Team name duplication')
    return (1,'Team Updated')

def create_team(name,manager,private='open',notes='',viewing='allmembers'):
    # needs some error testing
    if manager.rower.rowerplan == 'basic':
        if manager.rower.protrialexpires < timezone.now().date() and manager.rower.plantrialexpires < timezone.now().date():
            return (0,'You need to upgrade to a paid plan to establish a team')
    if manager.rower.rowerplan not in ('coach','freecoach'):
        ts = Team.objects.filter(manager=manager)
        if len(ts)>=1:
            return (0,'You need to upgrade to the Coach plan to have more than one team')
    
    try:
        t = Team(name=name,manager=manager,notes=notes,
                 private=private,viewing=viewing)
        t.save()
        r = Rower.objects.get(user=manager)
        res = add_member(t.id,r)
    except IntegrityError:
        return (0,'Team name duplication')
    return (t.id,'Team created')

def remove_team(id):
    t = Team.objects.get(id=id)
    for r in Rower.objects.filter(team=t):
        send_team_delete_mail(t,r)
    return t.delete()

#def set_teamplanexpires(rower):
#    ts = Team.objects.filter(rower=rower)

#    texp = datetime.date(timezone.now())

#    for t in ts:
#        print t.name
#        mr = Rower.objects.get(user=t.manager)
#        if mr.teamplanexpires > texp:
#            rower.teamplanexpires = mr.teamplanexpires

#        t.save()

    return (1,'Updated rower team expiry')

def add_coach(coach,rower):
    # get coaching group
    
    coachgroup = coach.mycoachgroup
    if coachgroup is None:
        coachgroup = CoachingGroup(name=coach.user.first_name)
        coachgroup.save()
        coach.mycoachgroup = coachgroup
        coach.save()

    if get_coach_club_size(coach)<coach.clubsize:
        rower.coachinggroups.add(coach.mycoachgroup)
        
        return (1,"Added Coach")
    else:
        return (0,"Maximum number of athletes reached")

def add_member(id,rower):
    t= Team.objects.get(id=id)
    try:
        rower.team.add(t)
    except ValidationError as e:
        return(0,"Couldn't add member: "+str(e.message))
        
    # code to add all workouts
    ws = Workout.objects.filter(user=rower)
    
    res = handle_add_workouts_team(ws,t)

#    set_teamplanexpires(rower)
        
    return (id,'Member added')

def remove_member(id,rower):
    t = Team.objects.get(id=id)
    rower.team.remove(t)
    # remove the team from rower's workouts:
    ws = Workout.objects.filter(user=rower,team=t)

    res = handle_remove_workouts_team(ws,t)
            
#    set_teamplanexpires(rower)
    return (id,'Member removed')

def remove_coach(coach,rower):
    try:
        coachgroup = coach.mycoachgroup
    except CoachingGroup.DoesNotExist:
        coachgroup = CoachingGroup()
        coachgroup.save()
        coach.mycoachgroup = coachgroup
        coach.save()
        
    rower.coachinggroups.remove(coachgroup)

    return (1,'Coach removed')

def rower_get_managers(rower):
    managers = []
    for team in rower.team.all():
        managers.append(team.manager.rower)

    return managers

def rower_get_coaches(rower):
    coaches = []
    for group in rower.coachinggroups.all():
        try:
            coach = Rower.objects.get(mycoachgroup=group)
            coaches.append(coach)
        except Rower.DoesNotExist:
            pass

    return coaches
    

def coach_getcoachees(coach):
    if coach.mycoachgroup and coach.rowerplan in ('coach','freecoach'):
        return Rower.objects.filter(
            coachinggroups__in=[coach.mycoachgroup]
        ).distinct().order_by("user__last_name","user__first_name")
    else:
        return []

def coach_remove_athlete(coach,rower):
    try:
        coachgroup = coach.mycoachgroup
    except CoachingGroup.DoesNotExist:
        coachgroup = CoachingGroup()
        coachgroup.save()
        coach.mycoachgroup = coachgroup
        coach.save()
        
    rower.coachinggroups.remove(coachgroup)

    return (1,'Coach removed')

def mgr_remove_member(id,manager,rower):
    t = Team.objects.get(id=id)
    if t.manager == manager:
        remove_member(id,rower)
        send_email_member_dropped(id,rower)
        return (id,'Member removed')
    else:
        return (0,'You are not the team manager')

    return (0,'')

def count_invites(manager):
    ts = Team.objects.filter(manager=manager)
    count = 0
    for t in ts:
        count += TeamInvite.objects.filter(team=t).count()

    return count


def count_club_members(manager):
    ts = Team.objects.filter(manager=manager)
    return Rower.objects.filter(team__in=ts).distinct().count()


# Medium level functionality

# request by user to be coached by coach
def create_coaching_request(coach,user):
    if coach in rower_get_coaches(user.rower):
        return (0,'Already coached by that coach')

    codes = [i.code for i in CoachRequest.objects.all()]
    code = uuid.uuid4().hex[:10].upper()
    while code in codes:
        code = uuid.uuid4().hex[:10].upper()

    if 'coach' in coach.rowerplan:
        rekwest = CoachRequest(coach=coach,user=user,code=code)
        rekwest.save()

        send_coachrequest_email(rekwest)

        return (rekwest.id,'The request was created')

    else:
        return (0,'That person is not a coach')

def send_coachrequest_email(rekwest):
    name = rekwest.user.first_name + " " + rekwest.user.last_name
    email = rekwest.coach.user.email

    code = rekwest.code

    coachname = rekwest.coach.user.first_name + " " + rekwest.coach.user.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_coachrequest,
                  email,name,code,coachname)
        
def send_coacheerequest_email(rekwest):
    name = rekwest.user.first_name + " " + rekwest.user.last_name
    email = rekwest.user.email

    code = rekwest.code

    coachname = rekwest.coach.user.first_name + " " + rekwest.coach.user.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_coacheerequest,
                  email,name,code,coachname)
        
def create_request(team,user):
    r2 = Rower.objects.get(user=user)
    r = Rower.objects.get(user=team.manager)
    if r2 in Rower.objects.filter(team=team):
        return (0,'Already a member of that team')

    #    if count_club_members(team.manager)+count_invites(team.manager) <= r.clubsize:
    codes = [i.code for i in TeamRequest.objects.all()]
    code = uuid.uuid4().hex[:10].upper()
    # prevent duplicates
    while code in codes:
        code = uuid.uuid4().hex[:10].upper()

    u = User.objects.get(id=user)
    rekwest = TeamRequest(team=team,user=u,code=code)
    rekwest.save()
    
    send_request_email(rekwest)
        
    return (rekwest.id,'The request was created')
    
    return (0,'Something went wrong in create_request')

def get_coach_club_size(coach):
    rs = Rower.objects.filter(coachinggroups__in=[coach.mycoachgroup])
    rekwests = CoachOffer.objects.filter(coach=coach)

    result = len(rs)+len(rekwests)

    return result


# request by coach to coach user
def create_coaching_offer(coach,user):
    r = user.rower

    if coach in rower_get_coaches(user.rower):
        return (0,'You are already coaching this person.')

    codes = [i.code for i in CoachOffer.objects.all()]
    code = uuid.uuid4().hex[:10].upper()
    while code in codes:
        code = uuid.uuid4().hex[:10].upper()

    if 'coach' in coach.rowerplan and get_coach_club_size(coach)<coach.clubsize:
        rekwest = CoachOffer(coach=coach,user=user,code=code)
        rekwest.save()

        send_coacheerequest_email(rekwest)

        return (rekwest.id,'The request was created')
    elif get_coach_club_size(coach)>=coach.clubsize:
        return(0,'You have reached the maximum number of athletes')

    else:
        return (0,'You are not a coach')


    

def create_invite(team,manager,user=None,email=''):
    r = Rower.objects.get(user=manager)
    if team.manager != manager:
        return (0,'Not the team manager')
    if user:
        try:
            r2 = Rower.objects.get(user=user)
            email = r2.user.email
        except Rower.DoesNotExist:
            return (0,'Rower does not exist')
        if r2 in Rower.objects.filter(team=team):
            return (0,'Already member of that team')
    elif email==None or email=='':
        return (0,'Invalid request - missing email or user')
    else:
        try:
            r2 = Rower.objects.get(user__email=email)
            user = User.objects.get(rower=r2)
        except Rower.DoesNotExist:
            user=None
        except Rower.MultipleObjectsReturned:
            return (0,'There is more than one user with that email address')
            
    #    if count_club_members(team.manager)+count_invites(team.manager) <= r.clubsize:
    codes = [i.code for i in TeamInvite.objects.all()]
    code = uuid.uuid4().hex[:10].upper()
    # prevent duplicates
    while code in codes:
        code = uuid.uuid4().hex[:10].upper()

    invite = TeamInvite(team=team,code=code,user=user,email=email)
    invite.save()
    return (invite.id,'Invitation created')
        
        
    return (0,'Nothing done')

def revoke_request(user,id):
    try:
        rekwest = TeamRequest.objects.get(id=id)
    except TeamRequest.DoesNotExist:
        return (0,'The request is invalid')

    t = rekwest.team

    if rekwest.user==user:
        rekwest.delete()
        return (1,'Request revoked')
    else:
        return (0,'You are not the requestor')

def reject_revoke_coach_offer(user,id):
    try:
        rekwest = CoachOffer.objects.get(id=id)
    except CoachOffer.DoesNotExist:
        return (0,'The request is invalid')

    if rekwest.coach.user == user:
        rekwest.delete()
        
        return (1,'Request removed')
    elif rekwest.user == user:
        send_coachoffer_rejected_email(rekwest)
        rekwest.delete()
        return (1,'Request removed')
    else:
        return (0,'Not permitted')
    
def reject_revoke_coach_request(user,id):
    try:
        rekwest = CoachRequest.objects.get(id=id)
    except CoachRequest.DoesNotExist:
        return (0,'The request is invalid')

    if rekwest.coach.user == user:
        send_coachrequest_rejected_email(rekwest)
        rekwest.delete()
        return (1,'Request rejected')
    elif rekwest.user == user:
        rekwest.delete()
        return (1,'Request rejected')
    else:
        return (0,'Not permitted')

def revoke_invite(manager,id):
    try:
        invite = TeamInvite.objects.get(id=id)
    except TeamInvite.DoesNotExist:
        return (0,'The invitation is invalid')

    if invite.team.manager==manager:
        invite.delete()
        return (1,'Invitation revoked')
    else:
        return (0,'You are not the team manager')
    
def reject_request(manager,id):
    try:
        rekwest = TeamRequest.objects.get(id=id)
    except TeamRequest.DoesNotExist:
        return (0,'The request is invalid')

    if rekwest.team.manager==manager:
        send_request_reject_email(rekwest)
        rekwest.delete()
        return (1,'Request rejected')
    else:
        return (0,'You are not the manager for this request')

    
def reject_invitation(user,id):
    try:
        invite = TeamInvite.objects.get(id=id)
    except TeamInvite.DoesNotExist:
        return (0,'The invitation is invalid')

    if invite.user==user:
        send_invite_reject_email(invite)
        invite.delete()
        return (1,'Invitation rejected')
    else:
        return (0,'This request was not for you')


def send_invite_email(id):
    try:
        invitation = TeamInvite.objects.get(id=id)
    except TeamInvite.DoesNotExist:
        return (0,'Invitation doesn not exist')
        
    if invitation.user:
        email = invitation.user.email
        name = invitation.user.first_name + " " + invitation.user.last_name
    else:
        email = invitation.email
        name = ''
        
    code = invitation.code
    teamname = invitation.team.name
    manager = invitation.team.manager.first_name+' '+invitation.team.manager.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_invite,
	          email,name,code,teamname,manager)

    return (1,'Invitation email sent')

def send_team_delete_mail(t,rower):
    u = rower.user
    teamname = t.name
    email = u.email
    name = u.first_name+' '+u.last_name
    manager = t.manager.first_name+' '+t.manager.last_name
    res = myqueue(queuehigh,
                  handle_sendemail_team_removed,
	          email,name,teamname,manager)

    return (1,'Team delete email sent')

def send_email_member_dropped(teamid,rower):
    t = Team.objects.get(id=teamid)
    u = rower.user
    teamname = t.name
    email = u.email
    name = u.first_name+' '+u.last_name
    manager = t.manager.first_name+' '+t.manager.last_name

    res = myqueue(queuehigh,handle_sendemail_member_dropped,
	          email,name,teamname,manager)

    return (1,'Member dropped email sent')
    

def send_request_accept_email(rekwest):
    id = rekwest.id
    email = rekwest.user.email
    teamname = rekwest.team.name
    name = rekwest.user.first_name+' '+rekwest.user.last_name
    manager = rekwest.team.manager.first_name+' '+rekwest.team.manager.last_name
    res = myqueue(queuehigh,
                  handle_sendemail_request_accept,
	          email,name,teamname,manager)

    return (1,'Invitation email sent')
    

def send_request_reject_email(rekwest):
    id = rekwest.id
    teamname = rekwest.team.name
    email = rekwest.user.email
    name = rekwest.user.first_name+' '+rekwest.user.last_name
    manager = rekwest.team.manager.first_name+' '+rekwest.team.manager.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_request_reject,
	          email,name,teamname,manager)

    return (1,'Invitation email sent')


def send_invite_reject_email(invitation):
    id = invitation.id
    email = invitation.team.manager.email
    if invitation.user:
        name = invitation.user.first_name+' '+invitation.user.last_name
    else:
        name = invitation.email

    teamname = invitation.team.name
    manager = invitation.team.manager.first_name+' '+invitation.team.manager.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_invite_reject,
	          email,name,teamname,manager)

    return (1,'Invitation email sent')


def send_invite_accept_email(invitation):
    id = invitation.id
    email = invitation.team.manager.email
    if invitation.user:
        name = invitation.user.first_name+' '+invitation.user.last_name
    else:
        name = invitation.email

    teamname = invitation.team.name
    manager = invitation.team.manager.first_name+' '+invitation.team.manager.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_invite_accept,
	          email,name,teamname,manager)

    return (1,'Invitation email sent')

def send_team_message(team,message):
    rowers = team.rower.all()
    managername = team.manager.first_name + " " + team.manager.last_name

    for rower in rowers:
        rowername = rower.user.first_name + " " + rower.user.last_name
        res = myqueue(queuehigh,
                      handle_sendemail_message,
                      rower.user.email,team.manager.email,rowername,message,team.name,managername)

    return (1,'message sent')

def send_request_email(rekwest):
    email = rekwest.team.manager.email
    id = rekwest.id
    name = rekwest.team.manager.first_name + " " + rekwest.team.manager.last_name
    code = rekwest.code
    teamname = rekwest.team.name
    requestor = rekwest.user.first_name+' '+rekwest.user.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_request,
	          email,name,code,teamname,requestor,id)

    return (1,'Invitation email sent')

def process_request_code(manager,code):
    code = code.upper()
    
    try:
        rekwest = TeamRequest.objects.get(code=code)
    except TeamRequest.DoesNotExist:
        return (0,'The request has been revoked or the code is invalid')

    r = Rower.objects.get(user=rekwest.user)
    t = rekwest.team

    if rekwest.team.manager != manager:
        return (0,'You are not the manager of this team')

    result,comment = add_member(t.id,r)
    if not result:
        return (result,"The member couldn't be added")

    
    send_request_accept_email(rekwest)
            
        
    rekwest.delete()
    return (result,'The member was added')

def process_invite_code(user,code):
    code = code.upper()
    try:
        invitation = TeamInvite.objects.get(code=code)
    except TeamInvite.DoesNotExist:
        return (0,'The invitation has expired or the code is invalid')

    r = Rower.objects.get(user=user)
    nu = datetime.date(timezone.now())
    if nu > invitation.issuedate+timedelta(days=inviteduration):
        revoke_invite(invitation.team.manager,invitation.id)
        return (0,'The invitation has expired')
    
    t = invitation.team
    result, comment = add_member(t.id,r)
    if not result:
        return (result,"The member couldn't be added")


    send_invite_accept_email(invitation)
    invitation.delete()
    return (result,'You were added to the team')

def remove_expired_invites():
    issuedate = timezone.now()-timedelta(days=inviteduration)
    issuedate = datetime.date(issuedate)
    invitations = TeamInvite.objects.filter(issuedate__lt=issuedate)
    for i in invitations:
        revoke_invite(i.team.manager,i.id)

    return (1,'Expired invitations deleted')

def process_coachrequest_code(coach,code):
    code = code.upper()

    try:
        rekwest = CoachRequest.objects.get(code=code)
    except CoachRequest.DoesNotExist:
        return (0,'The request has been revoked or is invalid')

    if rekwest.coach != coach:
        return (0,'The request is invalid')

    result = add_coach(coach,rekwest.user.rower)
    if not result:
        return result
    else:
        send_coachrequest_accepted_email(rekwest)

    rekwest.delete()

    return result

def process_coachoffer_code(user,code):
    code = code.upper()

    try:
        rekwest = CoachOffer.objects.get(code=code)
    except CoachOffer.DoesNotExist:
        return (0,'The request has been revoked or is invalid')

    if rekwest.user != user:
        return (0,'The request is invalid')

    result = add_coach(rekwest.coach,rekwest.user.rower)
    if not result:
        return result
    else:
        send_coachoffer_accepted_email(rekwest)
        
    rekwest.delete()

    return result

def send_coachoffer_rejected_email(rekwest):
    coachname = rekwest.coach.user.first_name + " " + rekwest.coach.user.last_name
    coachemail = rekwest.coach.user.email

    name = rekwest.user.first_name + " " + rekwest.user.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_coachoffer_rejected,
                  coachemail,coachname,name)

def send_coachrequest_rejected_email(rekwest):
    coachname = rekwest.coach.user.first_name + " " + rekwest.coach.user.last_name
    email = rekwest.user.email

    name = rekwest.user.first_name + " " + rekwest.user.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_coachrequest_rejected,
                  email,coachname,name)

def send_coachrequest_accepted_email(rekwest):
    coachname = rekwest.coach.user.first_name + " " + rekwest.coach.user.last_name
    email = rekwest.user.email

    name = rekwest.user.first_name + " " + rekwest.user.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_coachrequest_accepted,
                  email,coachname,name)
    

def send_coachoffer_accepted_email(rekwest):
    coachname = rekwest.coach.user.first_name + " " + rekwest.coach.user.last_name
    coachemail = rekwest.coach.user.email

    name = rekwest.user.first_name + " " + rekwest.user.last_name

    res = myqueue(queuehigh,
                  handle_sendemail_coachoffer_accepted,
                  coachemail,coachname,name)