from rowers.forms import TeamInviteCodeForm

from rowers.views.statements import *

from rowers.rower_rules import *


def get_team_by_pk(request, team_id):
    return get_object_or_404(Team, pk=team_id)


@login_required()
@permission_required('teams.view_team', fn=get_team_by_pk, raise_exception=True)
def team_view(request, team_id=0, userid=0):
    ismember = 0
    hasrequested = 0
    r = getrequestrower(request, userid=userid)

    myteams, memberteams, otherteams = get_teams(request)
    teams.remove_expired_invites()

    t = get_object_or_404(Team, pk=team_id)

    q = User.objects.filter(rower__isnull=False, rower__team__in=myteams).distinct(
    ).exclude(rower__team__name=t.name)
    mygroups = [request.user.rower.mycoachgroup]
    q2 = User.objects.filter(rower__isnull=False, rower__coachinggroups__in=mygroups).distinct(
    ).exclude(rower__team__name=t.name)

    q = q | q2

    if request.method == 'POST' and request.user == t.manager and 'email' in request.POST:
        inviteform = TeamInviteForm(request.POST)

        inviteform.fields['user'].queryset = q
        if inviteform.is_valid():
            cd = inviteform.cleaned_data
            newmember = cd['user']
            email = cd['email']
            inviteid, text = teams.create_invite(t, t.manager,
                                                 user=newmember,
                                                 email=email)
            if inviteid:
                teams.send_invite_email(inviteid)
                successmessage = text
                messages.info(request, successmessage)
            else:  # pragma: no cover
                message = text
                messages.error(request, message)
        groupmessageform = TeamMessageForm()
    elif request.method == 'POST' and request.user == t.manager and 'message' in request.POST:  # pragma: no cover
        groupmessageform = TeamMessageForm(request.POST)
        inviteform = TeamInviteForm()
        if groupmessageform.is_valid():
            message = groupmessageform.cleaned_data['message']
            teams.send_team_message(t, message)
            messages.info(request, 'Message was sent to all team members')
        groupmessageform = TeamMessageForm()

    elif request.user == t.manager:
        inviteform = TeamInviteForm()
        inviteform.fields['user'].queryset = q
        groupmessageform = TeamMessageForm()
    else:
        inviteform = ''
        groupmessageform = ''

    members = Rower.objects.filter(team=t).order_by(
        'user__last_name', 'user__first_name')
    thisteammyrequests = TeamRequest.objects.filter(team=t, user=request.user)
    if len(thisteammyrequests):
        hasrequested = 1

    if r in members:
        ismember = 1

    breadcrumbs = [
        {
            'url': reverse(rower_teams_view),
            'name': 'Groups'
        },
        {
            'url': reverse(team_view, kwargs={'team_id': team_id}),
            'name': t.name
        }
    ]

    return render(request, 'team.html',
                  {
                      'team': t,
                      'teams': get_my_teams(request.user),
                      'myteams': myteams,
                      'memberteams': memberteams,
                      'groupmessageform': groupmessageform,
                      'members': members,
                      'breadcrumbs': breadcrumbs,
                      'active': 'nav-teams',
                      'inviteform': inviteform,
                      'ismember': ismember,
                      'hasrequested': hasrequested,
                  })


@login_required()
def team_leaveconfirm_view(request, id=0):
    try:
        t = Team.objects.get(id=id)
    except Team.DoesNotExist:  # pragma: no cover # pragma: no cover
        raise Http404("Team doesn't exist")

    myteams, memberteams, otherteams = get_teams(request)

    breadcrumbs = [
        {
            'url': reverse(rower_teams_view),
            'name': 'Groups'
        },
        {
            'url': reverse(team_view, kwargs={'team_id': id}),
            'name': t.name
        },
        {
            'url': reverse(team_leaveconfirm_view, kwargs={'id': id}),
            'name': 'Leave'
        }
    ]
    return render(request, 'teamleaveconfirm.html',
                  {
                      'team': t,
                      'teams': get_my_teams(request.user),
                      'myteams': myteams,
                      'memberteams': memberteams,
                      'otherteams': otherteams,
                      'active': 'nav-teams',
                      'breadcrumbs': breadcrumbs,
                  })


@login_required()
def rower_calcdps_view(request):
    r = getrower(request.user)

    ws = [(w.id, w.csvfilename) for w in Workout.objects.filter(user=r)]
    _ = myqueue(queue, handle_updatedps, r.user.email, ws, debug=False,
                emailbounced=r.emailbounced)

    messages.info(
        request, "Your workouts are being updated in the background. You will receive email when this is done.")

    url = reverse('workouts_view')
    return HttpResponseRedirect(url)


@login_required()
def team_leave_view(request, id=0):
    r = getrower(request.user)
    teams.remove_member(id, r)

    url = reverse(rower_teams_view)
    response = HttpResponseRedirect(url)
    return response


def get_teams(request):
    r = Rower.objects.get(user=request.user)

    myteams = Team.objects.filter(
        manager=request.user).order_by('name')
    memberteams = Team.objects.filter(
        rower=r).exclude(manager=request.user).order_by('name')
    otherteams = Team.objects.filter(
        private='open').exclude(
            rower=r).exclude(manager=request.user).order_by('name')

    if user_is_basic(request.user):
        otherteams = otherteams.filter(manager__rower__rowerplan='pro')

    return myteams, memberteams, otherteams


@login_required()
def rower_teams_view(request):  # pragma: no cover
    if request.method == 'POST':
        form = TeamInviteCodeForm(request.POST)
        if form.is_valid():
            code = form.cleaned_data['code']
            res, text = teams.process_invite_code(request.user, code)
            if res:
                messages.info(request, text)
            else:
                messages.error(request, text)
    else:
        form = TeamInviteCodeForm()

    r = getrower(request.user)
    ts = Team.objects.filter(rower=r)

    myteams, memberteams, otherteams = get_teams(request)
    teams.remove_expired_invites()

    invites = TeamInvite.objects.filter(user=request.user)
    requests = TeamRequest.objects.filter(user=request.user)
    myrequests = TeamRequest.objects.filter(team__in=myteams)
    myinvites = TeamInvite.objects.filter(team__in=myteams)

    # user invites (as coach)
    mycoachoffers = CoachOffer.objects.filter(coach=r)
    # user is invited (by coach)
    coachoffers = CoachOffer.objects.filter(user=r.user)

    # user requests a coach
    mycoachrequests = CoachRequest.objects.filter(user=r.user)
    # user is requested to coach
    coachrequests = CoachRequest.objects.filter(coach=r)

    invitedathletes = [rekwest.user for rekwest in mycoachoffers]
    invitedcoaches = [rekwest.coach for rekwest in mycoachrequests]
    invitedcoaches += [rekwest.coach for rekwest in coachoffers]
    invitingathletes = [rekwest.user for rekwest in coachrequests]

    coaches = teams.rower_get_coaches(r)

    potentialcoaches = [
        t.manager for t in memberteams if t.manager not in coaches and 'pro' in t.manager.rower.rowerplan]
    offercoaches = [
        r.user for r in Rower.objects.all().exclude(user=request.user) if r.can_coach()
    ]
    potentialcoaches = list(set(potentialcoaches+offercoaches))
    potentialcoaches = [
        c for c in potentialcoaches if c.rower not in invitedcoaches+coaches]

    coachees = teams.coach_getcoachees(request.user.rower)

    if is_coach(request.user) or is_coachtrial(request.user):
        potentialathletes = Rower.objects.filter(
            team__in=myteams).exclude(
                user__in=invitedathletes).exclude(
                    user=request.user
        ).exclude(coachinggroups__in=[request.user.rower.mycoachgroup])
    else:
        potentialathletes = []

    potentialathletes = [
        a for a in potentialathletes if a.user not in invitingathletes]

    #    clubsize = teams.count_invites(request.user)+teams.count_club_members(request.user)
    #   max_clubsize = r.clubsize

    breadcrumbs = [
        {
            'url': reverse(rower_teams_view),
            'name': 'Groups'
        }
    ]

    return render(request, 'teams.html',
                  {
                      'teams': ts,
                      'active': 'nav-teams',
                      'breadcrumbs': breadcrumbs,
                      'myteams': myteams,
                      'memberteams': memberteams,
                      'invites': invites,
                      'otherteams': otherteams,
                      'requests': requests,
                      'myrequests': myrequests,
                      'form': form,
                      'myinvites': myinvites,
                      'mycoachrequests': mycoachrequests,
                      'mycoachoffers': mycoachoffers,
                      'coachrequests': coachrequests,
                      'coachoffers': coachoffers,
                      'coaches': coaches,
                      'potentialcoaches': potentialcoaches,
                      'coachees': coachees,
                      'potentialathletes': potentialathletes,
                  })


@login_required()
def invitation_revoke_view(request, id):
    res, text = teams.revoke_invite(request.user, id)
    if res:
        messages.info(request, text)
    else:  # pragma: no cover
        messages.error(request, text)

    url = reverse(rower_teams_view)

    return HttpResponseRedirect(url)


@login_required()
def manager_member_drop_view(request, teamid, userid,
                             message='', successmessage=''):
    rower = Rower.objects.get(user__id=userid)
    res, text = teams.mgr_remove_member(teamid, request.user, rower)
    if res:
        messages.info(request, text)
    else:  # pragma: no cover
        messages.error(request, text)

    url = reverse(rower_teams_view)

    return HttpResponseRedirect(url)


@login_required()
def manager_requests_view(request, code=None):
    if code:
        res, text = teams.process_request_code(request.user, code)
        if res:  # pragma: no cover
            messages.info(request, text)
        else:
            messages.error(request, text)

    url = reverse(rower_teams_view, kwargs={
    })
    return HttpResponseRedirect(url)


@login_required()
def athlete_drop_coach_confirm_view(request, id):
    r = getrower(request.user)
    try:
        coach = Rower.objects.get(id=id)
    except Rower.DoesNotExist:  # pragma: no cover # pragma: no cover
        raise Http404("This rower doesn't exist")
    if coach not in teams.rower_get_coaches(r):  # pragma: no cover
        raise PermissionDenied("You are not allowed to do this")

    breadcrumbs = [
        {
            'url': reverse('rower_teams_view'),
            'name': 'Groups'
        },
        {
            'url': reverse('athlete_drop_coach_confirm_view', kwargs={'id': id}),
            'name': 'Confirm drop athlete'
        }
    ]

    return render(request, 'dropcoachconfirm.html',
                  {
                      'rower': r,
                      'coach': coach,
                      'breadcrumbs': breadcrumbs,
                  })


@login_required()
def coach_drop_athlete_confirm_view(request, id):
    r = getrower(request.user)
    try:
        rower = Rower.objects.get(id=id)
    except Rower.DoesNotExist:  # pragma: no cover # pragma: no cover
        raise Http404("This rower doesn't exist")
    if rower not in teams.coach_getcoachees(r):  # pragma: no cover
        raise PermissionDenied("You are not allowed to do this")

    breadcrumbs = [
        {
            'url': reverse('rower_teams_view'),
            'name': 'Groups'
        },
        {
            'url': reverse('coach_drop_athlete_confirm_view', kwargs={'id': id}),
            'name': 'Confirm drop athlete'
        }
    ]

    return render(request, 'dropathleteconfirm.html',
                  {
                      'rower': r,
                      'athlete': rower,
                      'breadcrumbs': breadcrumbs,
                  })


@login_required()
def coach_drop_athlete_view(request, id):
    r = getrower(request.user)
    try:
        rower = Rower.objects.get(id=id)
    except Rower.DoesNotExist:  # pragma: no cover
        raise Http404("This rower doesn't exist")
    if rower not in teams.coach_getcoachees(r):  # pragma: no cover
        raise PermissionDenied("You are not allowed to do this")

    res, text = teams.coach_remove_athlete(r, rower)

    if res:
        messages.info(request, 'You are not coaching this athlete any more')
    else:  # pragma: no cover
        messages.error(
            request, 'There was an error dropping the athlete from your list')

    url = reverse('rower_teams_view')

    return HttpResponseRedirect(url)


@login_required()
def athlete_drop_coach_view(request, id):
    r = getrower(request.user)
    try:
        coach = Rower.objects.get(id=id)
    except Rower.DoesNotExist:  # pragma: no cover
        raise Http404("This coach doesn't exist")
    if coach not in teams.rower_get_coaches(r):  # pragma: no cover
        raise PermissionDenied("You are not allowed to do this")

    res, text = teams.coach_remove_athlete(coach, r)

    if res:
        messages.info(request, 'Removal successful')
    else:  # pragma: no cover
        messages.error(
            request, 'There was an error dropping the coach from your list')

    url = reverse('rower_teams_view')

    return HttpResponseRedirect(url)


@login_required()
def team_requestmembership_view(request, teamid, userid):
    try:
        t = Team.objects.get(id=teamid)
    except Team.DoesNotExist:  # pragma: no cover
        raise Http404("Team doesn't exist")

    r = getrequestrower(request, userid=userid)

    # if t.manager.rower.rowerplan in ['plan','pro'] and r.rowerplan == 'basic':
    if not can_join_team(r.user, t):
        messages.error(request,
                       "You have to be on a paid plan (Pro or higher) to join this team."
                       " As a basic user you can only join teams managed by users on the Coach plan.")

        url = reverse('paidplans_view')
        return HttpResponseRedirect(url)

    res, text = teams.create_request(t, userid)
    if res:
        messages.info(request, text)
    else:  # pragma: no cover
        messages.error(request, text)

    url = reverse('team_view', kwargs={
        'team_id': int(teamid),
    })

    return HttpResponseRedirect(url)


@login_required()
def request_coaching_view(request, coachid):
    coach = User.objects.get(id=coachid).rower

    if is_coach(coach.user) or is_coachtrial(request.user):
        res, text = teams.create_coaching_request(coach, request.user)
        if res:
            messages.info(request, text)
        else:  # pragma: no cover
            messages.error(request, text)
    else:  # pragma: no cover
        messages.error(request, 'That person is not a coach')

    url = reverse('rower_teams_view')

    return HttpResponseRedirect(url)


@user_passes_test(iscoachmember, login_url="/rowers/paidplans", redirect_field_name=None)
def offer_coaching_view(request, userid):
    try:
        u = User.objects.get(id=userid)
    except User.DoesNotExist:  # pragma: no cover
        raise Http404("This user doesn't exist")

    coach = getrequestrower(request)

    res, text = teams.create_coaching_offer(coach, u)

    if res:
        messages.info(request, text)
    else:  # pragma: no cover
        messages.error(request, text)

    url = reverse('rower_teams_view')

    return HttpResponseRedirect(url)


@login_required()
def reject_revoke_coach_request(request, id=0):
    res, text = teams.reject_revoke_coach_request(request.user, id)

    if res:
        messages.info(request, text)
    else:  # pragma: no cover
        messages.error(request, text)

    url = reverse('rower_teams_view')

    return HttpResponseRedirect(url)


@login_required()
def reject_revoke_coach_offer(request, id=0):
    res, text = teams.reject_revoke_coach_offer(request.user, id)

    if res:
        messages.info(request, text)
    else:  # pragma: no cover
        messages.error(request, text)

    url = reverse('rower_teams_view')

    return HttpResponseRedirect(url)


@login_required()
def request_revoke_view(request, id=0):
    res, text = teams.revoke_request(request.user, id)

    if res:
        messages.info(request, text)

    else:  # pragma: no cover
        messages.error(request, text)

    url = reverse(rower_teams_view)

    return HttpResponseRedirect(url)


@login_required()
def request_reject_view(request, id=0):
    res, text = teams.reject_request(request.user, id)

    if res:
        messages.info(request, text)
    else:  # pragma: no cover
        messages.error(request, text)

    url = reverse(rower_teams_view)

    return HttpResponseRedirect(url)


@login_required()
def invitation_reject_view(request, id=0):
    res, text = teams.reject_invitation(request.user, id)

    if res:
        messages.info(request, text)
    else:  # pragma: no cover
        messages.error(request, text)

    url = reverse(rower_teams_view)

    return HttpResponseRedirect(url)


@login_required()
def rower_invitations_view(request, code=None, message='', successmessage=''):
    if code:
        teams.remove_expired_invites()
        
        res, text = teams.process_invite_code(request.user, code)
        if res:  # pragma: no cover
            messages.info(request, text)
            teamid = res
            url = reverse(team_view, kwargs={
                'team_id': teamid,
            })
        else:
            messages.error(request, text)

            url = reverse(rower_teams_view)

        return HttpResponseRedirect(url)

    url = reverse(rower_teams_view, kwargs={
    })
    return HttpResponseRedirect(url)


@login_required()
@permission_required('teams.change_team', fn=get_team_by_pk, raise_exception=True)
def team_edit_view(request, team_id=0):
    t = get_object_or_404(Team, pk=team_id)

    if request.method == 'POST':  # pragma: no cover
        teamcreateform = TeamForm(request.POST, instance=t)
        if teamcreateform.is_valid():
            cd = teamcreateform.cleaned_data
            name = cd['name']
            notes = cd['notes']
            manager = request.user
            private = cd['private']
            viewing = cd['viewing']
            res, message = teams.update_team(t, name, manager, private, notes,
                                             viewing)
            if res:
                messages.info(request, message)
            else:
                messages.error(request, message)

            url = reverse(team_view,
                          kwargs={
                              'team_id': int(team_id),
                          }
                          )

            response = HttpResponseRedirect(url)
            return response

    else:
        teamcreateform = TeamForm(instance=t)

    myteams, memberteams, otherteams = get_teams(request)

    breadcrumbs = [
        {
            'url': reverse(rower_teams_view),
            'name': 'Groups'
        },
        {
            'url': reverse(team_view, kwargs={'team_id': team_id}),
            'name': t.name
        },
        {
            'url': reverse(team_edit_view, kwargs={'team_id': team_id}),
            'name': 'Edit'
        }
    ]

    return render(request, 'teamedit.html',
                  {
                      'form': teamcreateform,
                      'teams': get_my_teams(request.user),
                      'myteams': myteams,
                      'memberteams': memberteams,
                      'otherteams': otherteams,
                      'active': 'nav-teams',
                      'breadcrumbs': breadcrumbs,
                      'team': t,
                  })


@login_required()
@user_passes_test(can_add_team, login_url="/rowers/paidplans", redirect_field_name=None,
                  message="You need to upgrade or log in to access this functionality")
def team_create_view(request):
    r = getrequestrower(request)

    if request.method == 'POST':
        teamcreateform = TeamForm(request.POST)
        if teamcreateform.is_valid():
            cd = teamcreateform.cleaned_data
            name = cd['name']
            notes = cd['notes']
            manager = request.user
            private = cd['private']
            viewing = cd['viewing']
            res, message = teams.create_team(name, manager, private, notes,
                                             viewing)

            if not res:  # pragma: no cover
                messages.error(request, message)
                url = reverse('paidplans_view')
                return HttpResponseRedirect(url)

            url = reverse('rower_teams_view')
            response = HttpResponseRedirect(url)
            return response

    else:
        teamcreateform = TeamForm()

    myteams, memberteams, otherteams = get_teams(request)

    breadcrumbs = [
        {
            'url': reverse(rower_teams_view),
            'name': 'Groups'
        },
        {
            'url': reverse(team_create_view),
            'name': "New Team"
        },
    ]
    return render(request, 'teamcreate.html',
                  {
                      'teams': get_my_teams(request.user),
                      'form': teamcreateform,
                      'myteams': myteams,
                      'memberteams': memberteams,
                      'otherteams': otherteams,
                      'active': 'nav-teams',
                      'rower': r,
                      'breadcrumbs': breadcrumbs,
                  })

# @login_required()


@permission_required('teams.delete_team', fn=get_team_by_pk, raise_exception=True)
def team_deleteconfirm_view(request, team_id):
    r = getrower(request.user)
    t = get_object_or_404(Team, pk=team_id)

    myteams, memberteams, otherteams = get_teams(request)

    breadcrumbs = [
        {
            'url': reverse(rower_teams_view),
            'name': 'Groups'
        },
        {
            'url': reverse(team_view, kwargs={'team_id': team_id}),
            'name': t.name
        },
        {
            'url': reverse(team_deleteconfirm_view, kwargs={'team_id': team_id}),
            'name': 'Leave'
        }
    ]
    return render(request, 'teamdeleteconfirm.html',
                  {
                      'teams': get_my_teams(request.user),
                      'team': t,
                      'myteams': myteams,
                      'memberteams': memberteams,
                      'otherteams': otherteams,
                      'rower': r,
                      'breadcrumbs': breadcrumbs,
                      'active': 'nav-teams',
                  })


@login_required()
@permission_required('teams.delete_team', fn=get_team_by_pk, raise_exception=True)
def team_delete_view(request, team_id):
    t = get_object_or_404(Team, pk=team_id)

    teams.remove_team(t.id)

    url = reverse(rower_teams_view)
    response = HttpResponseRedirect(url)
    return response


@login_required()
@permission_required('teams.change_team', fn=get_team_by_pk, raise_exception=True)
def team_members_stats_view(request, team_id):
    r = getrower(request.user)
    t = get_object_or_404(Team, pk=team_id)

    members = Rower.objects.filter(team=t).order_by(
        "user__last_name", "user__first_name")

    theusers = [member.user for member in members]

    myteams, memberteams, otherteams = get_teams(request)

    breadcrumbs = [
        {
            'url': reverse(rower_teams_view),
            'name': 'Groups'
        },
        {
            'url': reverse(team_view, kwargs={'team_id': team_id}),
            'name': t.name
        },
        {
            'url': reverse(team_members_stats_view, kwargs={'team_id': team_id}),
            'name': 'Members Stats'
        }
    ]

    response = render(request, 'teamstats.html',
                      {
                          'teams': get_my_teams(request.user),
                          'myteams': myteams,
                          'memberteams': memberteams,
                          'otherteams': otherteams,
                          'active': 'nav-teams',
                          'breadcrumbs': breadcrumbs,
                          'team': t,
                          'rower': r,
                          'theusers': theusers,
                      })

    return response


@login_required()
def rower_accept_coachoffer_view(request, code=None):
    if code:
        res, text = teams.process_coachoffer_code(request.user, code)
        if res:
            messages.info(request, text)
        else:  # pragma: no cover
            messages.error(request, text)

    url = reverse('rower_teams_view')
    return HttpResponseRedirect(url)


@login_required()
def coach_accept_coachrequest_view(request, code=None):
    if code:
        res, text = teams.process_coachrequest_code(request.user.rower, code)
        if res:
            messages.info(request, text)
        else:  # pragma: no cover
            messages.error(request, text)

    url = reverse('rower_teams_view')
    return HttpResponseRedirect(url)