from django.utils.encoding import force_bytes, force_str
from rowers.tokens import account_activation_token
from django.contrib.sites.shortcuts import get_current_site
from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
from django.contrib.auth.backends import ModelBackend
from rowers.views.statements import *
from django.core.mail import EmailMessage
from django_ratelimit.decorators import ratelimit

from rowers import credits

@login_required()
def rower_idoklad_authorize(request):
    state=str(uuid4())
    
    params = {
        "client_id":IDOKLAD_CLIENT_ID,
        "response_type": "code",
        "redirect_uri": IDOKLAD_REDIRECT_URI,
        "scope": "idoklad_api offline_access",
    }

    url = "https://identity.idoklad.cz/server/connect/authorize?"+urllib.parse.urlencode(params)
    
    return HttpResponseRedirect(url)

@login_required()
def process_idokladcallback(request):
    dologging('idoklad.log',' /rowers/idokladcallback/')

    try:
        code = request.GET['code']
    except KeyError:
        error = request.GET['error']
        messages.error(request,error)
        return HttpResponseRedirect(reverse('workouts_view'))

    post_data = {
        'grant_type': "authorization_code",
        'client_id': IDOKLAD_CLIENT_ID,
        'client_secret': IDOKLAD_CLIENT_SECRET,
        'scope': 'idoklad_api offline_access',
        'code': code,
        'redirect_uri': IDOKLAD_REDIRECT_URI,
    }

    headers = {
        'Content-Type': 'application/x-www-form-urlencoded',
        }

    base_url = 'https://identity.idoklad.cz/server/connect/token'

    response = requests.post(base_url, data=post_data, headers=headers)

    if response.status_code == 200:
        result = response.json()
        try:
            t = iDokladToken.objects.all().order_by('-updated_at')[0]
            t.acces_token = result['access_token'],
            t.refresh_token = result['refresh_token']
            t.expires_in = result['expires_in']
            try:
                t.id_token = result['id_token']
            except KeyError:
                pass
            t.save()
            dologging("idoklad.log","Saving code to token "+str(t.id)+" with access_token: "+result['access_token'])
        except iDokladToken.DoesNotExist:
            t = iDokladToken(
                access_token = result['access_token'],
                refresh_token = result['refresh_token'],
                expires_in = result['expires_in'],
            )
            t.save()
            dologging("idoklad.log", "Creating new token "+str(t.id)+"with access_token: "+result['access_token'])
        messages.info(request,"Token refreshed and stored")
    else:
        messages.error(request,"Error")

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

@csrf_exempt
def braintree_webhook_view(request):
    dologging('braintreewebhooks.log',' /rowers/braintree/')
    if request.method == 'POST':
        result = braintreestuff.webhook(request)
        if result == 4:  # pragma: no cover
            raise PermissionDenied("Not allowed")

    return HttpResponse('')


def paidplans_view(request):
    if not request.user.is_anonymous:
        r = request.user.rower
        if r.paymentprocessor != 'braintree' and r.paymenttype == 'recurring':  # pragma: no cover
            messages.error(request, 'Automated payment processing is currently only available through" \
                           " BrainTree (by PayPal). You are currently on a recurring payment plan with PayPal." \
                           " Contact the site administrator at support@rowsandall.com before you proceed')
    else:
        r = None

    return render(request,
                  'paidplans.html',
                  {'rower': r})


@login_required()
def billing_view(request):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    if r.paymentprocessor != 'braintree' and r.paymenttype == 'recurring':  # pragma: no cover
        messages.error(request, 'Automated payment processing is currently only available through" \
                       " BrainTree (by PayPal). You are currently on a recurring payment plan with PayPal." \
                       " Contact the site administrator at support@rowsandall.com before you proceed')

    if payments.is_existing_customer(r):  # pragma: no cover
        url = reverse(upgrade_view)
        return HttpResponseRedirect(url)

    if request.method == 'POST':
        billingaddressform = RowerBillingAddressForm(request.POST)
        planselectform = PlanSelectForm(
            request.POST, paymentprocessor='braintree')
        if billingaddressform.is_valid():
            cd = billingaddressform.cleaned_data
            for attr, value in cd.items():
                try:
                    setattr(r, attr, value)
                    r.save()
                except:
                    pass

        if billingaddressform.is_valid():
            if planselectform.is_valid():
                plan = planselectform.cleaned_data['plan']
                try:
                    _ = braintreestuff.create_customer(r)
                except ProcessorCustomerError:  # pragma: no cover
                    messages.error(
                        request, "Something went wrong registering you as a customer.")
                    url = reverse(billing_view)
                    return HttpResponseRedirect(url)
                url = reverse(payment_confirm_view,
                              kwargs={
                                  'planid': plan.id
                              })
                return HttpResponseRedirect(url)

    else:
        billingaddressform = RowerBillingAddressForm(instance=r)
        planselectform = PlanSelectForm(paymentprocessor='braintree')

    return render(request,
                  'billing.html',
                  {'rower': r,
                   'billingaddressform': billingaddressform,
                   'planselectform': planselectform,
                   })


def buy_trainingplan_view(request, id=0):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    targets = TrainingTarget.objects.filter(
        rowers=r,
        date__gte=timezone.now(),
    ).order_by("-date")

    plan = get_object_or_404(InstantPlan, pk=id)

    if r.paymentprocessor != 'braintree':  # pragma: no cover
        messages.error(
            request, "This purchase is currently only available through BrainTree (by PayPal)")

    if id == 0 or id is None:  # pragma: no cover
        messages.error(request, "There was an error accessing this plan")
        url = reverse('rower_view_instantplan', kwargs={
            'id': plan.uuid,
        })

        return HttpResponseRedirect(url)

    if request.method == 'POST':
        billingaddressform = RowerBillingAddressForm(instance=r)
        form = InstantPlanSelectForm(request.POST, targets=targets)
        if billingaddressform.is_valid():  # pragma: no cover
            cd = billingaddressform.cleaned_data
            for attr, value in cd.items():
                setattr(r, attr, value)
            r.save()

        # redirect to payment confirmation view
        if form.is_valid():
            cd = form.cleaned_data

            enddate = cd['enddate']
            startdate = cd['startdate']
            notes = cd['notes']
            datechoice = form.cleaned_data['datechoice']
            status = True

            # get target and set enddate
            try:  # pragma: no cover
                targetid = cd['target']
                target = TrainingTarget.objects.get(id=int(targetid))
            except (KeyError, ValueError):
                try:
                    targetid = request.POST['target']

                    if targetid != '':  # pragma: no cover
                        target = TrainingTarget.objects.get(id=int(targetid))
                    else:  # pragma: no cover
                        target = None
                except KeyError:
                    target = None

            if target and datechoice == 'target':  # pragma: no cover
                enddate = target.date
            elif datechoice == 'startdate':  # pragma: no cover
                enddate = startdate+datetime.timedelta(days=plan.duration)
            else:
                startdate = enddate-datetime.timedelta(days=plan.duration)

            pars = {
                'name': cd['name'],
                'enddate': enddate,
                'notes': notes,
                'status': status,
                'rower': r.id,
            }
            params = urllib.parse.urlencode(pars)
            url = reverse('confirm_trainingplan_purchase_view',
                          kwargs={'id': plan.id})
            url = url + "?%s" % params
            return HttpResponseRedirect(url)

    else:
        form = InstantPlanForm()
        billingaddressform = RowerBillingAddressForm(instance=r)

    return render(request,
                  'buy_trainingplan.html',
                  {
                      'rower': r,
                      'plan': plan,
                      'billingaddressform': billingaddressform,
                      'form': form,
                  })


def purchase_checkouts_view(request):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    if request.method != 'POST':  # pragma: no cover
        url = reverse('rower_view_instantplan', kwargs={
            'id': plan.uuid,
        })
        return HttpResponseRedirect(url)

    form = TrainingPlanBillingForm(request.POST)
    if form.is_valid():

        data = form.cleaned_data

        plan = InstantPlan.objects.get(id=data['plan'])
        authorizationstring = 'Bearer '+settings.WORKOUTS_FIT_TOKEN
        url = settings.WORKOUTS_FIT_URL+"/trainingplan/"+str(plan.uuid)
        headers = {'Authorization': authorizationstring}
        response = requests.get(url=url, headers=headers)
        if response.status_code != 200:  # pragma: no cover
            messages.error(
                request, "Could not connect to the training plan server")
            return HttpResponseRedirect(reverse('rower_select_instantplan'))

        amount, success = braintreestuff.make_payment(r, data)
        diff = plan.price - int(amount)

        _ = credits.withdraw(diff, r)

        if success:
            messages.info(
                request, "Your payment was completed and the sessions are copied to your calendar")
            plansteps = response.json()
            name = data['name']
            enddate = data['enddate']
            notes = data['notes']
            status = data['status']
            startdate = enddate-datetime.timedelta(days=plan.duration)

            # upgrade rower
            if r.rowerplan == 'basic':  # pragma: no cover
                messages.info(
                    request, 'You have been upgraded to the Self-Coach plan for the duration of the plan')
                r.rowerplan = 'plan'
                r.planexpires = enddate
                r.save()

            p = TrainingPlan(
                name=name,
                # target=target,
                manager=r,
                startdate=startdate,
                enddate=enddate, status=status,
                notes=notes,
            )

            p.save()

            p.rowers.add(r)

            create_sessions_from_json(plansteps, r, startdate, r.user)

            _ = myqueue(queuehigh, handle_send_email_instantplan_notification,
                        r.user.username,
                        r.user.email,
                        plan.price,
                        plan.name,
                        startdate,
                        enddate)

            url = reverse('plannedsessions_view')
            timeperiod = startdate.strftime(
                '%Y-%m-%d')+'/'+enddate.strftime('%Y-%m-%d')
            url = url+'?when='+timeperiod

            return HttpResponseRedirect(url)
        else:  # pragma: no cover
            messages.error(request, "There was a problem processing your payment. If the problem persists, please contact me through the <a href='/rowers/email/'>contact form</a>.")
            url = reverse('rower_view_instantplan', kwargs={
                'id': plan.uuid,
            })
            return HttpResponseRedirect(url)
    elif 'tac' not in request.POST:  # pragma: no cover
        try:
            enddate = request.POST['enddate']
            # incomplete
        except IndexError:
            messages.error(request, "There was an error in the payment form")
            url = reverse("purchase_checkouts_view")
            return HttpResponseRedirect(url)
    else:  # pragma: no cover
        messages.error(request, "There was an error in the payment form")

    url = reverse('rower_select_instantplan')  # pragma: no cover
    if 'plan' in request.POST:  # pragma: no cover
        plan = plan = InstantPlan.objects.get(id=request.POST['plan'])
        url = reverse('rower_view_instantplan', kwargs={
            'id': plan.uuid,
        })
    return HttpResponseRedirect(url)  # pragma: no cover


def confirm_trainingplan_purchase_view(request, id=0):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    if not can_plan(request.user):
        url = reverse('paidplans_view')
        messages.info(request,'You need to upgrade to Self-Coach or Coach first. On your training plan purchases you will get a discount.')
        return HttpResponseRedirect(url)

    r = request.user.rower

    plan = get_object_or_404(InstantPlan, pk=id)

    if r.paymentprocessor != 'braintree':  # pragma: no cover
        messages.error(
            request, "This purchase is currently only available through BrainTree (by PayPal)")

    if id == 0 or id is None:  # pragma: no cover
        messages.error(request, "There was an error accessing this plan")
        url = reverse('rower_view_instantplan', kwargs={
            'id': plan.uuid,
        })

        return HttpResponseRedirect(url)

    client_token = braintreestuff.get_client_token(r)

    enddate = request.GET.get('enddate', None)
    name = request.GET.get('name', '')
    status = request.GET.get('status', True)
    notes = request.GET.get('notes', '')
    if enddate is None:  # pragma: no cover
        messages.error(request, "There was an error accessing this plan")
        url = reverse('rower_view_instantplan', kwargs={
            'id': plan.uuid,
        })

    return render(request,
                  'confirm_trainingplan.html',
                  {
                      'plan': plan,
                      'client_token': client_token,
                      'rower': r,
                      'enddate': enddate,
                      'status': status,
                      'name': name,
                      'notes': notes,
                  })


@login_required()
def upgrade_view(request):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    if r.paymentprocessor != 'braintree' and r.paymenttype == 'recurring':  # pragma: no cover
        messages.error(request, 'Automated payment processing is currently only available through" \
                       " BrainTree (by PayPal). You are currently on a recurring payment plan with PayPal." \
                       " Contact the site administrator at support@rowsandall.com before you proceed')

    if r.subscription_id is None or r.subscription_id == '':  # pragma: no cover
        url = reverse(billing_view)
        return HttpResponseRedirect(url)

    if request.method == 'POST':
        billingaddressform = RowerBillingAddressForm(request.POST)
        planselectform = PlanSelectForm(
            request.POST, paymentprocessor='braintree')
        if billingaddressform.is_valid():
            cd = billingaddressform.cleaned_data
            for attr, value in cd.items():
                setattr(r, attr, value)
            r.save()

        if planselectform.is_valid():
            plan = planselectform.cleaned_data['plan']
            if billingaddressform.is_valid():
                url = reverse(upgrade_confirm_view,
                              kwargs={
                                  'planid': plan.id
                              })
                return HttpResponseRedirect(url)

    else:
        billingaddressform = RowerBillingAddressForm(instance=r)
        planselectform = PlanSelectForm(paymentprocessor='braintree',
                                        rower=r)

    return render(request,
                  'upgrade.html',
                  {'rower': r,
                   'billingaddressform': billingaddressform,
                   'planselectform': planselectform,
                   })


@login_required()
def downgrade_view(request):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    if r.paymentprocessor != 'braintree' and r.paymenttype == 'recurring':  # pragma: no cover
        messages.error(request, 'Automated payment processing is currently only available through" \
                       " BrainTree (by PayPal). You are currently on a recurring payment plan with PayPal." \
                       " Contact the site administrator at support@rowsandall.com before you proceed')

    if r.subscription_id is None or r.subscription_id == '':  # pragma: no cover
        url = reverse(billing_view)
        return HttpResponseRedirect(url)

    if request.method == 'POST':
        billingaddressform = RowerBillingAddressForm(request.POST)
        planselectform = PlanSelectForm(
            request.POST, paymentprocessor='braintree')
        if billingaddressform.is_valid():
            cd = billingaddressform.cleaned_data
            for attr, value in cd.items():
                setattr(r, attr, value)
            r.save()

        if planselectform.is_valid():
            plan = planselectform.cleaned_data['plan']

            if plan.price > r.paidplan.price:  # pragma: no cover
                nextview = upgrade_confirm_view
            elif plan.price == r.paidplan.price:  # pragma: no cover
                messages.info(request, 'You did not select a new plan')
                url = reverse(downgrade_view)
                return HttpResponseRedirect(url)
            else:
                nextview = downgrade_confirm_view

            if billingaddressform.is_valid():
                url = reverse(nextview,
                              kwargs={
                                  'planid': plan.id
                              })

                return HttpResponseRedirect(url)

    else:
        billingaddressform = RowerBillingAddressForm(instance=r)
        planselectform = PlanSelectForm(paymentprocessor='braintree',
                                        rower=r, includeall=True, initial={'plan': r.paidplan})

    return render(request,
                  'downgrade.html',
                  {'rower': r,
                   'billingaddressform': billingaddressform,
                   'planselectform': planselectform,
                   })


@login_required()
def plan_stop_view(request):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    subscriptions = []

    if r.paymentprocessor != 'braintree' and r.paymenttype == 'recurring':  # pragma: no cover
        messages.error(request, 'Automated payment processing is currently only available through" \
                       " BrainTree (by PayPal). You are currently on a recurring payment plan with PayPal." \
                       " Contact the site administrator at support@rowsandall.com before you proceed')

    if r.paidplan is not None and r.paidplan.paymentprocessor == 'braintree':
        try:
            subscriptions = braintreestuff.find_subscriptions(r)
        except ProcessorCustomerError:  # pragma: no cover
            r.paymentprocessor = None
            r.save()

    return render(request,
                  'subscriptions_cancel.html',
                  {'rower': r,
                   'subscriptions': subscriptions
                   })


@login_required()
def plan_tobasic_view(request, id=0):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    if r.paidplan.paymentprocessor == 'braintree':  # pragma: no cover
        success, themessages, errormessages = braintreestuff.cancel_subscription(
            r, id)
        for message in themessages:
            messages.info(request, message)

        for message in errormessages:
            messages.error(request, message)

    url = reverse(plan_stop_view)

    return HttpResponseRedirect(url)


@login_required()
def upgrade_confirm_view(request, planid=0):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    try:
        plan = PaidPlan.objects.get(id=planid)
    except PaidPlan.DoesNotExist:  # pragma: no cover
        messages.error(request, "Something went wrong. Please try again.")
        url = reverse(billing_view)
        return HttpResponseRedirect(url)

    r = request.user.rower

    if r.paymentprocessor != 'braintree' and r.paymenttype == 'recurring':  # pragma: no cover
        messages.error(request, 'Automated payment processing is currently only available through" \
                       " BrainTree (by PayPal). You are currently on a recurring payment plan with PayPal." \
                       " Contact the site administrator at support@rowsandall.com before you proceed')

    client_token = braintreestuff.get_client_token(r)

    return render(request,
                  "upgradeconfirm.html",
                  {
                      'plan': plan,
                      'client_token': client_token,
                      'rower': r,
                  })


@login_required()
def downgrade_confirm_view(request, planid=0):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    try:
        plan = PaidPlan.objects.get(id=planid)
    except PaidPlan.DoesNotExist:  # pragma: no cover
        messages.error(request, "Something went wrong. Please try again.")
        url = reverse(billing_view)
        return HttpResponseRedirect(url)

    r = request.user.rower

    client_token = braintreestuff.get_client_token(r)

    return render(request,
                  "downgradeconfirm.html",
                  {
                      'plan': plan,
                      'client_token': client_token,
                      'rower': r,
                  })


@login_required()
def payment_confirm_view(request, planid=0):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    try:
        plan = PaidPlan.objects.get(id=planid)
    except PaidPlan.DoesNotExist:  # pragma: no cover
        messages.error(request, "Something went wrong. Please try again.")
        url = reverse(billing_view)
        return HttpResponseRedirect(url)

    r = request.user.rower

    if r.paymentprocessor != 'braintree' and r.paymenttype == 'recurring':  # pragma: no cover
        messages.error(request, 'Automated payment processing is currently only available through" \
                       " BrainTree (by PayPal). You are currently on a recurring payment plan with PayPal." \
                       " Contact the site administrator at support@rowsandall.com before you proceed')

    client_token = braintreestuff.get_client_token(r)

    return render(request,
                  "paymentconfirm.html",
                  {
                      'plan': plan,
                      'client_token': client_token,
                      'rower': r,
                  })


@login_required()
def checkouts_view(request):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    if r.paymentprocessor != 'braintree' and r.paymenttype == 'recurring':  # pragma: no cover
        messages.error(request, 'Automated payment processing is currently only" \
                       " available through BrainTree (by PayPal). " \
                       "You are currently on a recurring payment plan with PayPal." \
                       " Contact the site administrator at support@rowsandall.com before you proceed')

    if request.method != 'POST':  # pragma: no cover
        url = reverse(paidplans_view)
        return HttpResponseRedirect(url)

    form = BillingForm(request.POST)
    if form.is_valid():
        data = form.cleaned_data
        success, amount = braintreestuff.create_subscription(r, data)
        if success:
            messages.info(
                request, "Your payment has succeeded and your plan has been updated")
            url = "{baseurl}?amount={amount:.2f}".format(
                baseurl=reverse(payment_completed_view),
                amount=amount)
            return HttpResponseRedirect(url)
        else:  # pragma: no cover
            messages.error(request, "There was a problem with your payment")
            url = reverse(billing_view)
            return HttpResponseRedirect(url)
    elif 'tac' not in request.POST:  # pragma: no cover
        try:
            planid = int(request.POST['plan'])
            url = reverse('payment_confirm_view', kwargs={'planid': planid})
            messages.error(
                request, "You must review and acknowledge the terms and conditions")
            return HttpResponseRedirect(url)
        except IndexError:
            messages.error(request, "There was an error in the payment form")
            url = reverse('billing_view')
            return HttpResponseRedirect(url)
    else:  # pragma: no cover
        messages.error(request, "There was an error in the payment form")
        url = reverse(billing_view)
        return HttpResponseRedirect(url)

    url = reverse(paidplans_view)  # pragma: no cover
    return HttpResponseRedirect(url)  # pragma: no cover


@login_required()
def upgrade_checkouts_view(request):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    if request.method != 'POST':  # pragma: no cover
        url = reverse(paidplans_view)
        return HttpResponseRedirect(url)

    form = BillingForm(request.POST)
    if form.is_valid():
        data = form.cleaned_data
        success, amount = braintreestuff.update_subscription(r, data)
        if success:
            messages.info(
                request, "Your payment has succeeded and your plan has been updated")
            url = "{baseurl}?amount={amount:.2f}".format(
                baseurl=reverse(payment_completed_view),
                amount=amount)
            return HttpResponseRedirect(url)
        else:  # pragma: no cover
            messages.error(request, "There was a problem with your payment")
            url = reverse(upgrade_view)
            return HttpResponseRedirect(url)

    elif 'tac' not in request.POST:  # pragma: no cover
        try:
            planid = int(request.POST['plan'])
            url = reverse('upgrade_confirm_view', kwargs={'planid': planid})
            messages.error(
                request, "You must review and acknowledge the terms and conditions")
            return HttpResponseRedirect(url)
        except IndexError:
            messages.error(request, "There was an error in the payment form")
            url = reverse('billing_view')
            return HttpResponseRedirect(url)
    else:  # pragma: no cover
        messages.error(request, "There was an error in the payment form")
        url = reverse(upgrade_view)
        return HttpResponseRedirect(url)

    url = reverse(paidplans_view)  # pragma: no cover
    return HttpResponseRedirect(url)  # pragma: no cover


@login_required()
def downgrade_checkouts_view(request):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    if request.method != 'POST':  # pragma: no cover
        url = reverse(paidplans_view)
        return HttpResponseRedirect(url)

    form = BillingForm(request.POST)
    if form.is_valid():
        data = form.cleaned_data
        success = braintreestuff.update_subscription(r, data, method='down')
        if success:
            messages.info(request, "Your plan has been updated")
            url = reverse(downgrade_completed_view)
            return HttpResponseRedirect(url)
        else:  # pragma: no cover
            messages.error(
                request, "There was a problem with your transaction")
            url = reverse(upgrade_view)
            return HttpResponseRedirect(url)
    elif 'tac' not in request.POST:  # pragma: no cover
        try:
            planid = int(request.POST['plan'])
            url = reverse('downgrade_confirm_view', kwargs={'planid': planid})
            messages.error(
                request, "You must review and acknowledge the terms and conditions")
            return HttpResponseRedirect(url)
        except IndexError:
            messages.error(request, "There was an error in the payment form")
            url = reverse('billing_view')
            return HttpResponseRedirect(url)

    else:  # pragma: no cover
        messages.error(request, "There was an error in the payment form")
        url = reverse(upgrade_view)
        return HttpResponseRedirect(url)

    url = reverse(paidplans_view)  # pragma: no cover
    return HttpResponseRedirect(url)  # pragma: no cover


@login_required()
def payment_completed_view(request):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    amount = request.GET.get('amount', 0)

    r = request.user.rower

    return render(request,
                  "payment_completed.html",
                  {
                      'rower': r,
                      'amount': amount,
                  })


@login_required()
def downgrade_completed_view(request):
    if not PAYMENT_PROCESSING_ON:  # pragma: no cover
        url = reverse('promembership')
        return HttpResponseRedirect(url)

    r = request.user.rower

    return render(request,
                  "downgrade_completed.html",
                  {
                      'rower': r
                  })


# Email activation


def useractivate(request, uidb64, token):  # pragma: no cover
    try:
        uid = force_str(urlsafe_base64_decode(uidb64))
        user = User.objects.get(id=uid)
    except(TypeError, ValueError, OverflowError, User.DoesNotExist):
        user = None
    if user is not None and account_activation_token.check_token(user, token):
        user.is_active = True
        user.save()
        # below is old
        fullemail = user.first_name + " " + user.last_name + " " + "<" + user.email + ">"
        subject = "Thank you for registering on rowsandall.com"
        from_address = 'Sander Roosendaal <info@rowsandall.com>'

        d = {'first_name': user.first_name}

        template = 'registeremail.html'

        send_template_email(from_address, [fullemail],
                            subject, template, d)

        subject2 = "New User"
        message2 = "New user registered.\n"
        message2 += fullemail + "\n"
        message2 += "User name: "+user.username

        send_mail(subject2, message2,
                  'Rowsandall Server <info@rowsandall.com>',
                  ['roosendaalsander@gmail.com'])

        messages.info(
            request, 'Thank you for your email confirmation. You are now signed in to your account.')
        login(request, user, backend='django.contrib.auth.backends.ModelBackend')
        url = reverse('workouts_view')
        return HttpResponseRedirect(url)
    else:
        return render(request,
                      "invalid_activation.html",
                      {})


# User registration
@ratelimit(key='ip', rate='5/h', method='POST')
def rower_register_view(request):

    nextpage = request.GET.get('next', '/rowers/list-workouts/')
    if nextpage == '':  # pragma: no cover
        nextpage = '/rowers/list-workouts/'

    if request.method == 'POST':
        # Check if honeypot was triggered (optional logging)
        honeypot_value = request.POST.get('hp_field', '')
        if honeypot_value:
            # bot user, do not register
            messages.error(request, "Registration failed. Please try again.")
            url = reverse('rower_register_view')
            return HttpResponseRedirect(url)

        form = RegistrationFormSex(request.POST)
        if form.is_valid():
            first_name = form.cleaned_data['first_name']
            last_name = form.cleaned_data['last_name']
            email = form.cleaned_data['email']
            password = form.cleaned_data['password1']
            username = form.cleaned_data['username']
            sex = form.cleaned_data['sex']
            birthdate = form.cleaned_data['birthdate']
            weightcategory = form.cleaned_data['weightcategory']
            adaptiveclass = form.cleaned_data['adaptiveclass']
            nextpage = request.POST['next']
            try:
                theuser = User.objects.create_user(username, password=password)
            except:
                messages.error(request, "This user name already exists, choose another one")
                url = reverse('rower_register_view')
                return HttpResponseRedirect(url)
            theuser.first_name = first_name
            theuser.last_name = last_name
            theuser.email = email
            theuser.is_active = False
            theuser.save()

            birthdate = birthdate.replace(tzinfo=None)

            therower = Rower(user=theuser, sex=sex, birthdate=birthdate,
                             weightcategory=weightcategory,
                             adaptiveclass=adaptiveclass)

            therower.save()

            # create default favorite charts
            add_defaultfavorites(therower)

            # Create Sample workout
            f = 'media/testdata.csv.gz'
            timestr = strftime("%Y%m%d-%H%M%S")
            f2 = f[:-7]+timestr+'.csv.gz'
            copyfile(f, f2)

            response = dataprep.new_workout_from_file(therower, f2,
                                                      title='New User Sample Data',
                                                      notes='This is an example workout to get you started')
            newworkoutid = response[0]
            if newworkoutid:
                w = Workout.objects.get(id=newworkoutid)
                w.startdatetime = timezone.now()
                w.date = timezone.now().date()
                w.save()

            # Create and send email
            current_site = get_current_site(request)
            mail_subject = 'Activate your account.'
            to_email = form.cleaned_data.get('email')
            message = render_to_string('acc_activate_email.html', {
                'user': theuser,
                'domain': current_site.domain,
                'uid': urlsafe_base64_encode(force_bytes(theuser.id)),
                'token': account_activation_token.make_token(theuser),
            })
            to_email = form.cleaned_data.get('email')
            email = EmailMessage(
                mail_subject, message, to=[to_email]
            )
            try:
                email.send()
            except Exception as e:
                # send through alternative email server
                pass
            
            return render(request, 'confirmemailpage.html', {'address': to_email})

        #    login(request,theuser)

        #    return HttpResponseRedirect(nextpage)
        #        '/rowers/register/thankyou/')

        else:  # pragma: no cover
            return render(request,
                          "registration_form.html",
                          {'form': form,
                           'next': nextpage,
                           'timestamp': timezone.now().timestamp(),})
    else:
        form = RegistrationFormSex()
        return render(request,
                      "registration_form.html",
                      {'form': form,
                       'next': nextpage,
                       'timestamp': timezone.now().timestamp(),})

# User registration


def coach_register_view(request):  # pragma: no cover

    nextpage = request.GET.get('next', '/rowers/me/teams/')
    if nextpage == '':  # pragma: no cover
        nextpage = '/rowers/me/teams/'

    if request.method == 'POST':
        form = RegistrationFormSex(request.POST)
        if form.is_valid():
            first_name = form.cleaned_data['first_name']
            last_name = form.cleaned_data['last_name']
            email = form.cleaned_data['email']
            password = form.cleaned_data['password1']
            username = form.cleaned_data['username']
            sex = form.cleaned_data['sex']
            birthdate = form.cleaned_data['birthdate']
            weightcategory = form.cleaned_data['weightcategory']
            adaptiveclass = form.cleaned_data['adaptiveclass']
            nextpage = request.POST['next']
            theuser = User.objects.create_user(username, password=password)
            theuser.first_name = first_name
            theuser.last_name = last_name
            theuser.email = email
            theuser.save()

            birthdate = birthdate.replace(tzinfo=None)

            therower = Rower(user=theuser, sex=sex, birthdate=birthdate,
                             weightcategory=weightcategory,
                             adaptiveclass=adaptiveclass,
                             rowerplan='basic', clubsize=10)

            therower.save()

            # create default favorite charts
            add_defaultfavorites(therower)

            # Create and send email
            current_site = get_current_site(request)
            mail_subject = 'Activate your account.'
            to_email = form.cleaned_data.get('email')
            message = render_to_string('acc_activate_email.html', {
                'user': theuser,
                'domain': current_site.domain,
                'uid': urlsafe_base64_encode(force_bytes(theuser.id)),
                'token': account_activation_token.make_token(theuser),
            })
            to_email = form.cleaned_data.get('email')
            email = EmailMessage(
                mail_subject, message, to=[to_email]
            )
            email.send()
            return HttpResponse('Please confirm your email address to complete the registration')

            return HttpResponseRedirect(nextpage)

        else:  # pragma: no cover
            return render(request,
                          "freecoach_registration_form.html",
                          {'form': form,
                           'next': nextpage, })
    else:
        form = RegistrationFormSex()
        form.fields.pop('sex')
        form.fields.pop('weightcategory')
        form.fields.pop('adaptiveclass')
        return render(request,
                      "freecoach_registration_form.html",
                      {'form': form,
                       'next': nextpage, })


@login_required()
@permission_required('rower.is_staff', fn=get_user_by_userid, raise_exception=True)
def transactions_view(request):  # pragma: no cover
    if not request.user.is_staff:
        raise PermissionDenied("Not Allowed")

    if request.method == 'POST':
        dateform = DateRangeForm(request.POST)
        if dateform.is_valid():
            startdate = dateform.cleaned_data['startdate']
            enddate = dateform.cleaned_data['enddate']

            df = braintreestuff.get_transactions(startdate, enddate)
            filename = "transactions_{s}_{e}.csv".format(
                s=startdate, e=enddate)
            response = HttpResponse(df.to_csv())
            response['Content-Disposition'] = 'attachment; filename="%s"' % filename
            response['Content-Type'] = 'application/octet-stream'

            return response

    else:
        dateform = DateRangeForm()

    return render(request,
                  'transactions.html',
                  {
                      'dateform': dateform
                  })