from django.http import HttpResponse, HttpResponseRedirect, JsonResponse
from django.shortcuts import render
from django.core.files.storage import FileSystemStorage
from django.conf import settings
from django.utils import timezone
from django.contrib.auth import logout
from django.contrib.auth.models import User, auth
from django.contrib.auth.hashers import check_password
from django.contrib.auth import (login as auth_login,  authenticate)
from . models import University, KASNEB, KASNEB_PAPERS, KNEC_PAPERS, KNEC_DIPLOMA, KCPE, Lower, Account, Payment, KCSE
from .mpesa_credentials import MpesaAccessToken, MpesaAccessToke, LipanaMpesaPpassword, B2C, MpesaB2cCredential
from django.views.decorators.csrf import csrf_exempt
import requests
import json
from decimal import Decimal
from django.template.loader import render_to_string
import time
e_id = ""
from bs4 import BeautifulSoup
import re
from edu.settings import EMAIL_HOST_USER
from django.core.mail import send_mail


def index(request):
    return render(request, "index.html")
    
    
def cast(request):
    return render(request, "cast.html")


def education(request):
    edu_all = University.objects.filter(school="EDUCATION") & University.objects.filter(type="NOTES")
    return render(request, "un_education.html", {"edu_all": edu_all})


def education_pp(request):
    edu_pp = University.objects.filter(school="EDUCATION") & University.objects.filter(type="PAST PAPERS")
    return render(request, "pp_education.html", {"edu_pp": edu_pp})


def education_search(request):
    try:
        search = request.POST.get('search')
        edu_all = University.objects.filter(unit_name__contains=search) & University.objects.filter(school="EDUCATION")
        return render(request, "un_education.html", {"edu_all": edu_all})
    except Exception as e:
        return HttpResponseRedirect("/education")


def business(request):
    edu_all = University.objects.filter(school="BUSINESS") & University.objects.filter(type="NOTES")
    return render(request, "un_business.html", {"edu_all": edu_all})

def business_pp(request):
    edu_pp = University.objects.filter(school="EDUCATION") & University.objects.filter(type="PAST PAPERS")
    return render(request, "pp_business.html", {"edu_pp": edu_pp})


def business_search(request):
    try:
        search = request.POST.get('search')
        edu_all = University.objects.filter(unit_name__contains=search) & University.objects.filter(school="BUSINESS")
        return render(request, "un_business.html", {"edu_all": edu_all})
    except Exception as e:
        return HttpResponseRedirect("/business")


def it(request):
    edu_all = University.objects.filter(school="CIT") & University.objects.filter(type="NOTES")
    return render(request, "un_ict.html", {"edu_all": edu_all})

def it_pp(request):
    edu_pp = University.objects.filter(school="CIT") & University.objects.filter(type="PAST PAPERS")
    return render(request, "pp_ict.html", {"edu_pp": edu_pp})


def it_search(request):
    try:
        search = request.POST.get('search')
        edu_all = University.objects.filter(unit_name__contains=search) & University.objects.filter(school="CIT")
        return render(request, "un_ict.html", {"edu_all": edu_all})
    except Exception as e:
        return HttpResponseRedirect("/information_technology")


def economics(request):
    edu_all = University.objects.filter(school="ECONOMICS") & University.objects.filter(type="NOTES")
    return render(request, "un_economics.html", {"edu_all": edu_all})


def economics_pp(request):
    edu_pp = University.objects.filter(school="ECONOMICS") & University.objects.filter(type="PAST PAPERS")
    return render(request, "pp_economics.html", {"edu_pp": edu_pp})


def economics_search(request):
    try:
        search = request.POST.get('search')
        edu_all = University.objects.filter(unit_name__contains=search) & University.objects.filter(school="ECONOMICS")
        return render(request, "un_economics.html", {"edu_all": edu_all})
    except Exception as e:
        return HttpResponseRedirect("/economics")


def spas(request):
    edu_all = University.objects.filter(school="SPAS") & University.objects.filter(type="NOTES")
    return render(request, "un_spas.html", {"edu_all": edu_all})


def knec_diploma(request):
    return render(request, "knec_diploma.html")


def knec_diploma_cit(request):
    edu_all = KNEC_DIPLOMA.objects.filter(school="CIT") & KNEC_DIPLOMA.objects.filter(type="NOTES")
    return render(request, "knec_diploma_cit.html", {"edu_all": edu_all})


def knec_diploma_cit_search(request):
    try:
        search = request.POST.get('search')
        edu_all = KNEC_DIPLOMA.objects.filter(unit_name__contains=search) & KNEC_DIPLOMA.objects.filter(school="CIT")
        return render(request, "knec_diploma_cit.html", {"edu_all": edu_all})
    except Exception as e:
        return HttpResponseRedirect("/knec_diploma_cit")


def pay(request, lower_id):
    try:
        email = request.session["user"]
        am = request.POST.get("amount")
        path = request.build_absolute_uri()
        lower_id = str(path)[-1:]
        num = request.POST.get("phone")
        access_token = MpesaAccessToken.validated_mpesa_access_token
        api_url = "https://api.safaricom.co.ke/mpesa/stkpush/v1/processrequest"
        headers = {"Authorization": "Bearer %s" % access_token}
        request = {
            "BusinessShortCode": LipanaMpesaPpassword.Business_short_code,
            "Password": LipanaMpesaPpassword.decode_password,
            "Timestamp": LipanaMpesaPpassword.lipa_time,
            "TransactionType": "CustomerPayBillOnline",
            "Amount": am,
            "PartyA": num,  # replace with your phone number to get stk push
            "PartyB": LipanaMpesaPpassword.Business_short_code,
            "PhoneNumber": num,  # replace with your phone number to get stk push
            "CallBackURL": "https://edu.stansoftcorporation.com/callback",
            "AccountReference": "Stansoft Edu",
            "TransactionDesc": "Exam Payment"
        }

        response = requests.post(api_url, json=request, headers=headers)
        rendered = render_to_string('activator.html')
        return HttpResponse(rendered)
    except Exception as e:
        return HttpResponseRedirect("/exam_centre")


@csrf_exempt
def register_urls(request):
    access_token = MpesaAccessToken.validated_mpesa_access_token
    api_url = "https://api.safaricom.co.ke/mpesa/c2b/v1/registerurl"
    headers = {"Authorization": "Bearer %s" % access_token}
    options = {"ShortCode": LipanaMpesaPpassword.Test_c2b_shortcode,
               "ResponseType": "Completed",
               "ConfirmationURL": "https://mediumconnection.com/confirmation",
               "ValidationURL": "https://mediumconnection.com/validation"}
    response = requests.post(api_url, json=options, headers=headers)
    return HttpResponse(response.text)


@csrf_exempt
def call_back(request):
    try:
        json_data = json.loads(request.read().decode('utf-8'))
        body = json_data["Body"]
        data = body["stkCallback"]
        update_data = dict()
        update_data['result_code'] = data['ResultCode']
        update_data['result_description'] = data['ResultDesc']
        update_data['checkout_request_id'] = data['CheckoutRequestID']
        update_data['merchant_request_id'] = data['MerchantRequestID']
        meta_data = data['CallbackMetadata']['Item']
        if len(meta_data) > 0:
            # handle the meta data
            for item in meta_data:
                if len(item.values()) > 1:
                    key, value = item.values()
                    if key == 'MpesaReceiptNumber':
                        update_data['mpesa_receipt_number'] = value
                        t_id = update_data['mpesa_receipt_number']
                    if key == 'Amount':
                        update_data['amount'] = Decimal(value)
                        a = update_data['amount']
                    if key == 'PhoneNumber':
                        update_data['phone'] = int(value)
                        p = update_data['phone']
                    if key == 'TransactionDate':
                        date = str(value)
                        year, month, day, hour, min, sec = date[:4], date[4:-8], date[6:-6], date[8:-4], date[
                                                                                                         10:-2], date[
                                                                                                                 12:]
                        update_data['transaction_date'] = '{}-{}-{} {}:{}:{}'.format(year, month, day, hour, min, sec)
        amount = a
        transaction_id = t_id
        phone_number = p
        transaction_date = timezone.now() + timezone.timedelta(hours=3)
        # choose what to do with these variables

        message = {"ResultCode": 0, "ResultDesc": "The service was accepted successfully",
                   "ThirdPartyTransID": "account"}

        print(amount)
        print(transaction_id)
        print(phone_number)
        ph = str(phone_number)

        em = User.objects.values('email').get(last_name=ph[3:])['email']
        access = Account.objects.values('access').get(email=em)['access']

        code = str(e_id)
        new_access = (str(access)) + "," + code
        Account.objects.filter(email=em).update(access=new_access)
        transaction_date = timezone.now() + timezone.timedelta(hours=3)
        Payment.objects.create(amount=amount, transaction_id=transaction_id, phone_number=phone_number,
                               transaction_date=transaction_date)

        return JsonResponse({'message': message})

    except:
        message = {
            "ResultCode": 1,
            "ResultDesc": "There was an error processing the request",
            "ThirdPartyTransID": "freelance"}
        return JsonResponse({'message': message})


@csrf_exempt
def validation(request):
    context = {
        "ResultCode": 0,
        "ResultDesc": "Accepted"
    }

    return JsonResponse(dict(context))



def spas_pp(request):
    edu_pp = University.objects.filter(school="SPAS") & University.objects.filter(type="PAST PAPERS")
    return render(request, "pp_spas.html", {"edu_pp": edu_pp})


def spas_search(request):
    try:
        search = request.POST.get('search')
        edu_all = University.objects.filter(unit_name__contains=search) & University.objects.filter(school="SPAS")
        return render(request, "un_spas.html", {"edu_all": edu_all})
    except Exception as e:
        return HttpResponseRedirect("/spas")


def common_units(request):
    edu_all = University.objects.filter(school="COMMON") & University.objects.filter(type="NOTES")
    return render(request, "un_common_units.html", {"edu_all": edu_all})


def common_units_pp(request):
    edu_pp = University.objects.filter(school="COMMON") & University.objects.filter(type="PAST PAPERS")
    return render(request, "pp_common_units.html", {"edu_pp": edu_pp})


def common_units_search(request):
    try:
        search = request.POST.get('search')
        edu_all = University.objects.filter(unit_name__contains=search) & University.objects.filter(school="COMMON")
        return render(request, "un_common_units.html", {"edu_all": edu_all})
    except Exception as e:
        return HttpResponseRedirect("/common_units")


def cpa_notes(request):
    edu_all = KASNEB.objects.filter(school="CPA") & KASNEB.objects.filter(type="NOTES")
    return render(request, "un_cpanotes.html", {"edu_all": edu_all})


def cpa_notes_search(request):
    try:
        search = request.POST.get('search')
        edu_all = KASNEB.objects.filter(unit_name__contains=search)
        return render(request, "un_cpanotes.html", {"edu_all": edu_all})
    except Exception as e:
        return HttpResponseRedirect("/cpa_notes")


def cpa_papers(request):
    return render(request, "pp_cpahome.html")


def cpa_papers_2015(request):
    edu_all = KASNEB_PAPERS.objects.filter(school="CPA") & KASNEB_PAPERS.objects.filter(type="PAST PAPERS") \
              & KASNEB_PAPERS.objects.filter(year="2015")
    print(edu_all)

    return render(request, "pp_cpa2015.html", {"edu_all": edu_all})


def cpa_papers_2016(request):
    edu_all = KASNEB_PAPERS.objects.filter(school="CPA") & KASNEB_PAPERS.objects.filter(type="PAST PAPERS") \
              & KASNEB_PAPERS.objects.filter(year="2016")
    print(edu_all)

    return render(request, "pp_cpa2016.html", {"edu_all": edu_all})


def cpa_papers_2017(request):
    edu_all = KASNEB_PAPERS.objects.filter(school="CPA") & KASNEB_PAPERS.objects.filter(type="PAST PAPERS") \
              & KASNEB_PAPERS.objects.filter(year="2017")
    print(edu_all)

    return render(request, "pp_cpa2017.html", {"edu_all": edu_all})


def cpa_papers_2018(request):
    edu_all = KASNEB_PAPERS.objects.filter(school="CPA") & KASNEB_PAPERS.objects.filter(type="PAST PAPERS") \
              & KASNEB_PAPERS.objects.filter(year="2018")
    print(edu_all)

    return render(request, "pp_cpa2018.html", {"edu_all": edu_all})


def cpa_papers_2019(request):
    edu_all = KASNEB_PAPERS.objects.filter(school="CPA") & KASNEB_PAPERS.objects.filter(type="PAST PAPERS") \
              & KASNEB_PAPERS.objects.filter(year="2019")
    print(edu_all)

    return render(request, "pp_cpa2019.html", {"edu_all": edu_all})


def cpa_papers_2020(request):
    edu_all = KASNEB_PAPERS.objects.filter(school="CPA") & KASNEB_PAPERS.objects.filter(type="PAST PAPERS") \
              & KASNEB_PAPERS.objects.filter(year="2020")
    print(edu_all)

    return render(request, "pp_cpa2020.html", {"edu_all": edu_all})


def kcpe_papers(request):
    return render(request, "kcpe_papers.html")


def kcpe_2000(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2000")

    return render(request, "kcpe_2000.html", {"edu_all": edu_all})


def kcpe_2001(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2001")

    return render(request, "kcpe_2001.html", {"edu_all": edu_all})


def kcpe_2002(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2000")

    return render(request, "kcpe_2000.html", {"edu_all": edu_all})


def kcpe_2003(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2000")

    return render(request, "kcpe_2003.html", {"edu_all": edu_all})


def kcpe_2004(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2004")

    return render(request, "kcpe_2004.html", {"edu_all": edu_all})


def kcpe_2005(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2006")

    return render(request, "kcpe_2006.html", {"edu_all": edu_all})


def kcpe_2006(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2006")

    return render(request, "kcpe_2006.html", {"edu_all": edu_all})


def kcpe_2007(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2007")

    return render(request, "kcpe_2007.html", {"edu_all": edu_all})


def kcpe_2008(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2008")

    return render(request, "kcpe_2008.html", {"edu_all": edu_all})


def kcpe_2009(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2009")

    return render(request, "kcpe_2009.html", {"edu_all": edu_all})


def kcpe_2010(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2010")

    return render(request, "kcpe_2010.html", {"edu_all": edu_all})


def kcpe_2011(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2011")

    return render(request, "kcpe_2011.html", {"edu_all": edu_all})


def kcpe_2012(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2012")

    return render(request, "kcpe_2012.html", {"edu_all": edu_all})


def kcpe_2013(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2013")

    return render(request, "kcpe_2013.html", {"edu_all": edu_all})


def kcpe_2014(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2014")

    return render(request, "kcpe_2014.html", {"edu_all": edu_all})


def kcpe_2015(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2015")

    return render(request, "kcpe_2015.html", {"edu_all": edu_all})


def kcpe_2016(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2016")

    return render(request, "kcpe_2016.html", {"edu_all": edu_all})


def kcpe_2017(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2017")

    return render(request, "kcpe_2017.html", {"edu_all": edu_all})


def kcpe_2018(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2018")

    return render(request, "kcpe_2018.html", {"edu_all": edu_all})


def kcpe_2019(request):
    edu_all = KCPE.objects.filter(type="PAST PAPERS") \
              & KCPE.objects.filter(year="2019")

    return render(request, "kcpe_2019.html", {"edu_all": edu_all})


def kcse_papers(request):
    return render(request, "kcse_papers.html")


def kcse_2016(request):
    edu_all = KCSE.objects.filter(type="PAST PAPERS") \
              & KCSE.objects.filter(year="2019")

    return render(request, "kcse_2016.html", {"edu_all": edu_all})


def kcse_2017(request):
    edu_all = KCSE.objects.filter(type="PAST PAPERS") \
              & KCSE.objects.filter(year="2017")

    return render(request, "kcse_2017.html", {"edu_all": edu_all})


def kcse_2018(request):
    edu_all = KCSE.objects.filter(type="PAST PAPERS") \
              & KCSE.objects.filter(year="2018")

    return render(request, "kcse_2018.html", {"edu_all": edu_all})


def kcse_2019(request):
    edu_all = KCSE.objects.filter(type="PAST PAPERS") \
              & KCSE.objects.filter(year="2019")

    return render(request, "kcse_2016.html", {"edu_all": edu_all})


def kcse_2020(request):
    edu_all = KCSE.objects.filter(type="PAST PAPERS") \
              & KCSE.objects.filter(year="2020")

    return render(request, "kcse_2020.html", {"edu_all": edu_all})


def centre(request):
    try:
        fname = request.session['name']
        return render(request, "centre.html", {"fname": fname})
    except:
        return render(request, "centre.html")


def grade1_exams(request):
    try:
        fname = request.session['name']
        edu_all = Lower.objects.filter(grade="Grade I")
        return render(request, "grade1_exams.html", {"edu_all": edu_all, 'fname':fname})
    except:
        edu_all = Lower.objects.filter(grade="Grade I")
        return render(request, "grade1_exams.html", {"edu_all": edu_all})


def grade2_exams(request):
    try:
        fname = request.session['name']
        edu_all = Lower.objects.filter(grade="Grade II")
        return render(request, "grade2_exams.html", {"edu_all": edu_all, 'fname':fname})
    except:
        edu_all = Lower.objects.filter(grade="Grade II")
        return render(request, "grade2_exams.html", {"edu_all": edu_all})


def grade3_exams(request):
    try:
        fname = request.session['name']
        edu_all = Lower.objects.filter(grade="Grade III")
        return render(request, "grade3_exams.html", {"edu_all": edu_all, 'fname':fname})
    except:
        edu_all = Lower.objects.filter(grade="Grade III")
        return render(request, "grade3_exams.html", {"edu_all": edu_all})


def grade4_exams(request):
    try:
        fname = request.session['name']
        edu_all = Lower.objects.filter(grade="Grade IV")
        return render(request, "grade4_exams.html", {"edu_all": edu_all, 'fname':fname})
    except:
        edu_all = Lower.objects.filter(grade="Grade IV")
        return render(request, "grade4_exams.html", {"edu_all": edu_all})


def grade5_exams(request):
    try:
        fname = request.session['name']
        edu_all = Lower.objects.filter(grade="Grade V")
        return render(request, "grade5_exams.html", {"edu_all": edu_all, 'fname':fname})
    except:
        edu_all = Lower.objects.filter(grade="Grade V")
        return render(request, "grade5_exams.html", {"edu_all": edu_all})


def grade6_exams(request):
    try:
        fname = request.session['name']
        edu_all = Lower.objects.filter(grade="Grade VI")
        return render(request, "grade6_exams.html", {"edu_all": edu_all, 'fname':fname})
    except:
        edu_all = Lower.objects.filter(grade="Grade VI")
        return render(request, "grade6_exams.html", {"edu_all": edu_all})


def grade7_exams(request):
    try:
        fname = request.session['name']
        edu_all = Lower.objects.filter(grade="Grade VII")
        return render(request, "grade7_exams.html", {"edu_all": edu_all, 'fname':fname})
    except:
        edu_all = Lower.objects.filter(grade="Grade VII")
        return render(request, "grade7_exams.html", {"edu_all": edu_all})


def grade8_exams(request):
    try:
        fname = request.session['name']
        edu_all = Lower.objects.filter(grade="Grade VIII")
        return render(request, "grade8_exams.html", {"edu_all": edu_all, 'fname':fname})
    except:
        edu_all = Lower.objects.filter(grade="Grade VIII")
        return render(request, "grade8_exams.html", {"edu_all": edu_all})


def login(request):
    message = ''
    if request.method == 'POST':
        try:
            email = request.POST['email']
            if request.session['eid']:
                print("alaa")
                lower_id = request.session['eid']
                url2 = '/checkout/'+str(lower_id)
               
                password = request.POST['password']
                user = authenticate(username=email, password=password)
                if user is not None:
                    auth.login(request, user)
                    acc = User.objects.values('first_name').get(email=email)['first_name']
                    if lower_id !="":
                        request.session['name'] = acc
                        request.session['user'] = email
                        return HttpResponseRedirect(url2)

                else:
                    message = 'Incorrect login credentials. Please try again!'
           
        except Exception as e:
            try:
                password = request.POST['password']
                user = authenticate(username=email, password=password)
                if user is not None:
                    auth.login(request, user)
                    acc = User.objects.values('first_name').get(email=email)['first_name']
                   
                    request.session['name'] = acc
                    request.session['user'] = email
                    return render(request, "centre.html",
                      {"fname": acc})
                    
                else:
                    message = 'Incorrect login credentials. Please try again!'
                
            except:
                pass
               
                
    context = {'message': message}
    return render(request, "login.html", context)


def signup(request):
    error = ""
    if request.method == "POST":
        name = request.POST['name']
        email = request.POST['email']
        phone = request.POST['phone']
        password = request.POST['password']

        if User.objects.filter(email=email).exists() == False:
            if 'terms' in request.POST:
                user = User.objects.create_user(username=email, email=email,
                                         first_name=name, last_name=phone, password=password)
                user.save()
                account = Account.objects.create(user=user, email=email)
                account.save()
                return HttpResponseRedirect("login")
            else:
                error = "Please accept the terms and conditions"
        else:
            error = "The email address has been used. Use a different one!!"
        return render(request, "signup.html", {"error": error})
    return render(request, "signup.html")


def logout_view(request):
    logout(request)
    return HttpResponseRedirect("/exam_centre")


def profile(request):
    try:
        email = request.session['user']
        name = User.objects.values('first_name').get(email=email)['first_name']
        phone = User.objects.values('last_name').get(email=email)['last_name']

        return render(request, "profile.html", {'email':email,'fname':name, 'phone':phone})
    except Exception as e:
        return HttpResponseRedirect("/login")


def update_account(request):
    try:
        email = request.session['user']
        if request.method == "POST":
            name = request.POST['name']
            phone = request.POST['phone']
            User.objects.filter(email=email).update(first_name=name, last_name=phone)
            return HttpResponse("<script>alert('Your account was updated successfully');"
                                "window.location='/exam_centre'</script>")
    except:
        return HttpResponseRedirect("/login")
    return render(request, "profile.html")


def manage_password(request):
    try:
        email = request.session['user']
        fname = User.objects.values('first_name').get(email=email)['first_name']
        return render(request, "password.html", {"fname":fname})
    except:
        return HttpResponseRedirect("/login")


def change_password(request):
    try:
        message = ""
        email = request.session['user']
        old = request.POST.get('oldpass')
        pwd = request.POST.get('npass')
        cpwd = request.POST.get('cpass')

        fname = User.objects.values('first_name').get(email=email)['first_name']

        if request.method == "POST":
            p = User.objects.get(email=email)
            print(p)
            x = check_password(old, p.password)
            y = check_password(pwd, p.password)

            if x == True:
                if pwd == cpwd:
                    if len(pwd) >= 8:
                        if y == False:

                            u = User.objects.get(email=email)
                            u.set_password(pwd)
                            u.save()
                            return HttpResponse("<script>alert('The new password has been saved.');"
                                                "window.location='/logout'</script>")
                        else:
                            message= 'New password cannot be the same as old password.'
                    else:
                        message = 'The password is too short. It should be at least 8 characters.'
                else:
                    message =  'The two password do not match.'
            else:
                message =  "The old password is incorrect."
        return render(request, "password.html", {"message": message, "fname":fname})
    except Exception as e:
        #return HttpResponseRedirect("/exam_centre")
        return HttpResponseRedirect("/login")


def checkout(request, lower_id):
    try:
        email = ""
        if request.session['user']:
            print("weh")
            request.session['eid'] = lower_id
            email = request.session['user']
            fname = User.objects.values('first_name').get(email=email)['first_name']
            phone = User.objects.values('last_name').get(email=email)['last_name']
            exam_name = Lower.objects.values('exam_name').get(id=lower_id)['exam_name']
            return render(request, "checkout.html",
                      {'exam_name': exam_name, "phone": phone, "fname": fname, "lower_id": lower_id})
        else:
            request.session['eid'] = lower_id
            return HttpResponseRedirect("/login")
       
    except Exception as e:
        print(e)
        request.session['eid'] = lower_id
        return HttpResponseRedirect("/login")


def my_exams(request):
    try:
        email = request.session['user']
        fname = User.objects.values('first_name').get(email=email)['first_name']
        access = Account.objects.values('access').get(email=email)['access']
        arr = []
        new_access = str(access).split(",")
        for i in new_access:
            arr.append(i)
        arr.pop(0)
        arr = list(dict.fromkeys(arr))
        arr2=[]
        for q in arr:
            edu_all = Lower.objects.filter(id=q)
            arr2.append(edu_all)
        return render(request, "my_exams.html", {"edu_all": arr2, 'fname':fname})
    except Exception as e:
        return HttpResponseRedirect("/login")


def view_exam(request, exam_id):
    try:
        email = request.session['user']
        Lower.objects.get(id=exam_id)
        grade = Lower.objects.values('grade').get(id=exam_id)['grade']
        exam_name = Lower.objects.values('exam_name').get(id=exam_id)['exam_name']
        fname = User.objects.values('first_name').get(email=email)['first_name']
        literacy = Lower.objects.values('literacy').get(id=exam_id)['literacy']
        kiswahili = Lower.objects.values('kiswahili').get(id=exam_id)['kiswahili']
        english = Lower.objects.values('english').get(id=exam_id)['english']
        mathematical = Lower.objects.values('mathematical').get(id=exam_id)['mathematical']
        environmental = Lower.objects.values('environmental').get(id=exam_id)['environmental']
        religious = Lower.objects.values('religious').get(id=exam_id)['religious']
        movement = Lower.objects.values('movement').get(id=exam_id)['movement']
        hygiene = Lower.objects.values('hygiene').get(id=exam_id)['hygiene']

        #Upper
        composition = Lower.objects.values('composition').get(id=exam_id)['composition']
        insha = Lower.objects.values('insha').get(id=exam_id)['insha']
        marking_scheme = Lower.objects.values('marking_scheme').get(id=exam_id)['marking_scheme']
        science = Lower.objects.values('science').get(id=exam_id)['science']
        social_studies = Lower.objects.values('social_studies').get(id=exam_id)['social_studies']


        context = {
            'exam_name': exam_name, "fname": fname, "exam_id": exam_id,
            "literacy":literacy,
            'kiswahili':kiswahili,
            'english': english,
            'mathematical':mathematical,
            'environmental':environmental,
            'religious':religious,
            'movement': movement,
            'hygiene': hygiene,
            'grade': grade,
            'composition': composition,
            'insha': insha,
            'marking_scheme': marking_scheme,
            'science': science,
            'social_studies': social_studies,
        }

        return render(request, "view_exam.html",context)

    except Exception as e:
        return HttpResponseRedirect("/login")



def test(request):
    ph = "254700627742"
    em = User.objects.values('email').get(last_name=ph[3:])['email']
    access = Account.objects.values('access').get(email=em)['access']

    path = "https://145f-102-167-214-36.ngrok.io/1/pay"
    code = str(path)[-5]
    new_access = (str(access)) + "," + code
    Account.objects.filter(email=em).update(access=new_access)
    return HttpResponse(new_access)
    

def spinwriter(request):
    if request.method == 'POST':
        search = request.POST.get('original')
        ignore = request.POST.get('ignored')
        ignored = ignore.split()

        split = search.split()

        arr = []
        for i in split:

            arr.append(i)


            final_url = "https://www.thesaurus.com/browse/" + i + "?s=ts"
            req = requests.get(final_url)
            soup = BeautifulSoup(req.text, "html.parser")

            q = soup.select_one('.css-1kg1yv8.eh475bn0')
            print(q)
            if q is not None and i not in ignore :

                loc = arr.index(i)
                arr.remove(i)
                arr.insert(loc, q.text)

        rewriten = ' '.join([str(elem) for elem in arr])

        print(rewriten)
        return render(request, 'spin.html', {'arr':rewriten, 'orig':search, "ignore":ignore})
    else:
        return render(request, 'spin.html')


def cite_website(request):
    if "find" in request.POST:
        final_url = request.POST.get("url")
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36 Edge/12.0'
        }

        request.session['url'] = final_url
        response = requests.get(final_url, headers=headers)
        data = response.text
        soup = BeautifulSoup(data, features='html.parser')
        post_listings = soup.find_all("h1")
        print(post_listings)

        if len(post_listings) != 0:

            request.session['tit'] = post_listings[0].text
            authors = soup.select(".author")

            list_auth = []
            if len(authors) == 0:
                request.session['aut'] = []
                au = soup.find_all("meta", {"name": "author"})
                print(au)
                if len(au) > 0:
                    auth = au[0].get("content")
                    list_auth.append(auth)
                    request.session['aut'] = list_auth
                if len(au) == 0:
                    class_author = soup.select(".article-byline__name")
                    if len(class_author) > 0:
                        jauthor = class_author[0].text
                        list_auth.append(jauthor)
                        request.session['aut'] = list_auth
            else:
                for q in authors:
                    class_author1 = q.text
                    list_auth.append(class_author1)
                request.session['aut'] = list_auth

            pub = soup.select(".entry-date")

            if len(pub) == 0:

                pu = soup.find_all("meta", {"property": "org:pubdate"})
                for i in pu:

                    date = i.get("content")
                    if "20" in str(date):
                        loc = str(date).index("20")
                        request.session['dat'] = str(date[loc:loc + 4])
                    if "19" in str(date):
                        loc = str(date).index("19")
                        request.session['dat'] = str(date[loc:loc + 4])

                if len(pu) == 0:

                    pul = soup.find_all("meta", {"property": "article:published"})
                    if len(pul) == 0:
                        request.session['dat'] = "2020"

                    for i in pul:
                        dat = i.get("content")
                        if "20" in str(dat):
                            loc = str(dat).index("20")
                            request.session['dat'] = str(dat[loc:loc + 4])
                        if "19" in str(dat):
                            loc = str(dat).index("19")
                            request.session['dat'] = str(dat[loc:loc + 4])


            else:
                date = pub[0].text
                if "20" in str(date):
                    loc = str(date).index("20")
                    request.session['dat'] = str(date[loc:loc + 4])
                if "19" in str(date):
                    loc = str(date).index("19")
                    request.session['dat'] = str(date[loc:loc + 4])

            titlet = request.session['tit']
            yeart = request.session['dat']

            authors = request.session['aut']
            if "by" in str(authors):
                loc = str(authors[0]).index("by")
                final_auth = str(authors[0])[loc + 3:]
                authors.append(final_auth)
                authors.pop(0)
            if "By" in str(authors):
                new = str(authors[0])
                loc = str(authors[0]).index("By")
                final_auth = str(authors[0])[loc + 3:]
                authors.append(final_auth)
                authors.pop(0)
            request.session['authoros'] = authors
            if len(authors) == 0:
                request.session['authoros'] = []

            if "and " in str(authors):
                for i, s in enumerate(authors):
                    if "and" in s:
                        sub_and = str(authors[i])
                        nloc = sub_and.index("and")
                        sub_replace = sub_and.replace("and", ",")
                        a, b = sub_replace.split(",")
                        authors.append(a)
                        authors.append(b)
                        authors.pop(i)
                        request.session['authoros'] = authors
            writers = []
            for q in authors:
                qnames = q.split()
                namef = qnames[0].strip() + ", " + qnames[len(qnames) - 1].strip()
                writers.append(namef)
            if len(authors) == 2:

                name_one = writers[0].split()
                names_onef = name_one[len(name_one) - 1] + ", " + name_one[0].strip()

                name_two = writers[1].split()
                names_twof = name_two[len(name_two) - 1] + ", " + name_two[0].strip()
                names_auth = names_onef + " & " + names_twof
                request.session['names_auth'] = names_auth

                if len(authors) > 2:
                    names_aut = writers[0] + " et al.,"
                    request.session['names_auth'] = names_aut

            if len(authors) == 1:
                namef = authors[0].strip().split()
                namet = namef[0].strip() + ", " + namef[len(namef) - 1].strip()[0]
                request.session['names_auth'] = namet

            writersm = []
            if len(authors) > 1:
                for qm in authors:
                    fnm, lnm = qm.split()
                    namefm = lnm.strip() + ", " + fnm.strip()
                    writersm.append(namefm)

                if len(authors) == 2:
                    names_authm = writersm[0] + " & " + writersm[1]
                    request.session['names_authm'] = names_authm
                    print(names_authm)

                if len(authors) > 2:
                    names_autm = writers[0] + " et al.,"
                    request.session['names_authm'] = names_autm

            if len(authors) == 1:
                namef = authors[0].strip().split()
                namet = namef[0].strip() + ", " + namef[len(namef) - 1].strip()[0]
                request.session['names_auth'] = namet

            for i in authors:
                request.session['fauth'] = i.split()

            date = request.session['dat']
            title = request.session['tit']
            val = request.POST.get('apa')
        else:
           pass

        context = {"title": request.session['tit'], "year": request.session['dat'],
                   "authors": request.session['authoros'], "url": request.session['url']}

        return render(request, "citation.html", context)
    if "proceed" in request.POST:
        search = request.POST.getlist('article_author')

        authors = request.session['aut'] + search
        print(authors)
        if "by" in str(authors):
            loc = str(authors[0]).index("by")
            final_auth = str(authors[0])[loc + 3:]
            authors.append(final_auth)
            authors.pop(0)
        if "By" in str(authors):
            new = str(authors[0])
            loc = str(authors[0]).index("By")
            final_auth = str(authors[0])[loc + 3:]
            authors.append(final_auth)
            authors.pop(0)
        request.session['authoros'] = authors
        if len(authors) == 0:
            request.session['authoros'] = []

        if "and " in str(authors):
            for i, s in enumerate(authors):
                if "and" in s:
                    sub_and = str(authors[i])
                    nloc = sub_and.index("and")
                    sub_replace = sub_and.replace("and", ",")
                    a, b = sub_replace.split(",")
                    authors.append(a)
                    authors.append(b)
                    authors.pop(i)
                    request.session['authoros'] = authors
        writers = []
        if len(authors) > 1:

            for q in authors:
                qnames = q.split()
                namef = qnames[0].strip() + ", " + qnames[len(qnames) - 1].strip()
                writers.append(namef)
            print(writers)
            if len(authors) == 2:
                name_one = writers[0].split()
                names_onef = name_one[len(name_one) - 1] + ", " + name_one[0].strip()[0]

                name_two = writers[1].split()
                names_twof = name_two[len(name_two) - 1] + ", " + name_two[0].strip()[0]
                names_auth = names_onef + " & " + names_twof
                request.session['names_auth'] = names_auth

            if len(authors) > 2:

                names2 = []
                for j in writers:
                    jsplit = j.split()
                    jname = jsplit[len(jsplit) - 1] + ", " + jsplit[0].strip()[0]
                    names2.append(jname)

                last_names = names2[len(names2) - 2] + " & " + names2[len(names2) - 1]

                names2.pop(len(names2) - 1)

                names2.pop(len(names2) - 1)
                names2.append(last_names)
                names_many = ""
                for p in names2:
                    names_many = names_many + p + ", "
                names_aut = names_many

                request.session['names_auth'] = names_aut

        if len(authors) == 1:
            namef = authors[0].strip().split()
            namet = namef[0].strip() + ", " + namef[len(namef) - 1].strip()[0]
            request.session['names_auth'] = namet

        writersm = []
        if len(authors) > 1:
            for qm in authors:
                qnamesm = qm.split()
                namefm = qnamesm[0].strip() + ", " + qnamesm[len(qnamesm) - 1].strip()
                writersm.append(namefm)

            if len(authors) == 2:
                name_onem = writers[0].split()
                names_onefm = name_onem[len(name_onem) - 1] + ", " + name_onem[0].strip()

                name_twom = writers[1].split()
                names_twofm = name_twom[len(name_twom) - 1] + ", " + name_twom[0].strip()
                names_authm = names_onefm + " & " + names_twofm
                request.session['names_authm'] = names_authm

            if len(authors) > 2:
                names2m = []
                for jm in writersm:
                    jsplitm = jm.split()
                    jnamem = jsplitm[len(jsplitm) - 1] + ", " + jsplitm[0].strip()
                    names2m.append(jnamem)

                last_namesm = names2m[len(names2m) - 2] + " & " + names2m[len(names2m) - 1]

                names2m.pop(len(names2m) - 1)

                names2m.pop(len(names2m) - 1)
                names2m.append(last_namesm)
                names_manym = ""
                for pm in names2m:
                    names_manym = names_manym + pm + ", "
                names_autm = names_manym
                request.session['names_authm'] = names_autm

        if len(authors) == 1:
            namef = authors[0].strip().split()
            namet = namef[0].strip() + ", " + namef[len(namef) - 1].strip()
            request.session['names_authm'] = namet

        for i in authors:
            request.session['fauth'] = i.split()
        apa = request.session['names_auth'] + " . (" + request.session['dat'] + "). " + request.session[
            'tit'] + ". Retrieved from " + request.session['url']

        harvard = request.session[
                      'names_auth'] + " ., " + request.session['dat'] + ". " + request.session[
                      'tit'] + ". Retrieved from " + request.session['url']
        mla = request.session[
                  'names_authm'] + " . " + request.session['tit'] + "." + request.session[
                  'dat'] + ". " + " Retrieved from " + request.session['url']

        context = {"title": request.session['tit'], "year": request.session['dat'],
                   "authors": request.session['authoros'], "url": request.session['url'], "apa": apa, "mla": mla,
                   "harvard": harvard}
        return render(request, "web.html", context)
    else:
        return render(request, "citation.html")


def cite(request):
    if request.method == "POST":

        final_url = request.session['url']
        date = request.session['dat']
        title = request.session['tit']
        val = request.POST.get('apa')
        if "apa" in request.POST:
            if val == "apa":
                apa = request.session['names_auth']+" . (" + date + "). " + title + ". Retrieved from " + final_url
                context = {"apa":apa}
                return render(request, "citation.html", context)
            if val == "harvard":
                apa = request.session[
                          'names_auth'] + " ., " + date + ". " + title + ". Retrieved from " + final_url
                context = {"apa": apa}
                return render(request, "citation.html", context)
            if val == "chicago" or val == "mla":
                apa = request.session[
                          'names_authm'] + " . "+ title + "." + date + ". "+" Retrieved from " + final_url
                context = {"apa": apa}
                return render(request, "citation.html", context)
        else:
            error = "Please select a referencing style"
            return render(request, "citation.html", {"error":error})
    else:
        return render(request, "citation.html")


def synonyms(request):
    if request.method == 'POST':
        syno = request.POST.get('syno')
        final_url = "https://www.thesaurus.com/browse/" + syno + "?s=ts"
        req = requests.get(final_url)
        soup = BeautifulSoup(req.text, "html.parser")
        q = soup.select('.css-1kg1yv8.eh475bn0')
        syn = []
        for i in q:
            syn.append(i.text)
        return render(request, "synonyms.html", {"syn":syn, "syno":syno})
    else:
        return render(request, "synonyms.html")


def describe_noun(request):
    if request.method == "POST":
        search = request.POST.get('noun')
        final_url = "https://inspirassion.com/en/adj/"+search
        
        response = requests.get(final_url)
        data = response.text
        soup = BeautifulSoup(data, features='html.parser')
        ref = soup.find_all()
        
        span = soup.select(".result-group.text-start")
        print(span[0].text.split())
        adj = span[0].text.split()
       
        return render(request, "adjectives.html", {"adj":adj, "search":search})
    else:
        return render(request, "adjectives.html")


def cite_book(request):
    try:
        if request.method == "POST":
            book = request.POST.get('book')
            final_name = str(book).replace(" ", "+")
            final_url = "https://www.worldcat.org/search?q=" + final_name + "&qt=results_page"

            request.session['url'] = final_url
            r = requests.get(final_url)
            #data = response.text
            page_text = r.text.encode('utf-8').decode('ascii', 'ignore')
            soup = BeautifulSoup(page_text)

            title = soup.find_all("div", {"class": "name"})

            if len(title) != 0:

                request.session['tt'] = title[0].text
                author = soup.find_all("div", {"class": "author"})
                publisher = soup.find_all("span", {"class": "itemPublisher"})
                print(publisher[0].text)
                publi = str(publisher[0].text).split(":")
                publi.pop(0)
                new_pub = str(publi)[1:-2]
                pub_year = new_pub.split(",")

                year = pub_year[len(pub_year) - 1]
                pub_year.pop(len(pub_year) - 1)
                published = str(pub_year)[1:-2].replace('"', "").replace("'", "")

                request.session['pb'] = published
                if str(year).endswith(".") or str(year).endswith("]"):
                    final_year = year[-5:-1]
                    request.session["yr"] = final_year
                else:
                    final_year = year[-4:]
                    request.session["yr"] = final_year

                autho = str(author[0].text)[2:].replace(",", "")
                if str(autho).endswith(";"):
                    new_authors = autho[:-1]
                    request.session['final_au'] = new_authors
                else:
                    new_authors = autho
                    request.session['final_au'] = new_authors
                split_author = request.session['final_au'].split(";")
                request.session['all_authors'] = split_author

                writers = []

                if len(split_author) > 1:
                    for q in split_author:
                        qnames = q.split()
                        namef = qnames[0].strip() + ", " + qnames[len(qnames) - 1].strip()[0]

                        writers.append(namef)
                    if len(split_author) == 2:
                        names_auth = writers[0] + " & " + writers[1]
                        request.session['names_auth'] = names_auth

                    if len(split_author) > 2:
                        names2 = []
                        for j in writers:
                            jsplit = j.split()
                            jname = jsplit[len(jsplit) - 1] + ", " + jsplit[0].strip()[0]
                            names2.append(jname)

                        last_names = names2[len(names2) - 2] + " & " + names2[len(names2) - 1]

                        names2.pop(len(names2) - 1)

                        names2.pop(len(names2) - 1)
                        names2.append(last_names)
                        names_many = ""
                        for p in names2:
                            names_many = names_many + p + ", "
                        names_aut = names_many

                        request.session['names_auth'] = names_aut

                if len(split_author) == 1:
                    for q in split_author:
                        qnames = q.split()
                        names_aut = qnames[0].strip() + ", " + qnames[len(qnames) - 1].strip()[0]
                        request.session['names_auth'] = names_aut

                writersm = []
                if len(split_author) > 1:
                    for qm in split_author:
                        qmnames = qm.split()
                        namefm = qmnames[0].strip() + ", " + qmnames[len(qmnames) - 1].strip()
                        writersm.append(namefm)

                    if len(split_author) == 2:
                        names_authm = writersm[0] + " & " + writersm[1]
                        request.session['names_authm'] = names_authm
                        print(names_authm)

                    if len(split_author) > 2:
                        names2m = []
                        for jm in writersm:
                            jsplitm = jm.split()
                            jnamem = jsplitm[len(jsplitm) - 1] + ", " + jsplitm[0].strip()
                            names2m.append(jnamem)

                        last_namesm = names2m[len(names2m) - 2] + " & " + names2m[len(names2m) - 1]

                        names2m.pop(len(names2m) - 1)

                        names2m.pop(len(names2m) - 1)
                        names2m.append(last_namesm)
                        names_manym = ""
                        for pm in names2m:
                            names_manym = names_manym + pm + ", "
                        names_autm = names_manym
                        request.session['names_authm'] = names_autm

                if len(split_author) == 1:
                    for q in split_author:
                        qnames = q.split()
                        names_aut = qnames[0].strip() + ", " + qnames[len(qnames) - 1].strip()
                        request.session['names_authm'] = names_aut
            else:
                request.session['tt'] = ""
                request.session['all_authors'] = ""
                request.session['pb'] = ""
                request.session['yr'] = ""

            apa = request.session['names_auth'] + " . (" + request.session['yr'] + "). " + request.session[
                'tt'] + ". " + request.session['pb'] + "."

            harvard = request.session[
                          'names_auth'] + " ., " + request.session['yr'] + ". " + request.session['tt'] + ". " + \
                      request.session['pb'] + "."
            mla = request.session[
                      'names_authm'] + " . " + request.session['tt'] + "." + request.session['yr'] + ". " + \
                  request.session['pb'] + "."

            context = {"title": request.session['tt'], "year": request.session['yr'],
                       "authors": request.session['all_authors'], "pub": request.session['pb'],
                       "apa": apa,
                       "mla": mla,
                       "harvard": harvard}

            return render(request, "book.html", context)
    except Exception as e:
            return HttpResponse(e)


    return render(request, "book.html")



def cite_journal(request):
    try:
        if request.method == "POST":
            book = request.POST.get('book')
            final_name = str(book).replace(" ", "+")

            final_url = "https://www.springeropen.com/search?query=" + final_name + "&searchType=publisherSearch"

            request.session['url'] = final_url
            response = requests.get(final_url)
            data = response.text
            soup = BeautifulSoup(data, features='html.parser')

            title = soup.find_all("h3", {"itemprop": "name"})

            if len(title) != 0:

                request.session['tt'] = title[0].text
                author = soup.find_all("span", {"class": "c-listing__authors-list"})
                publisher = soup.find_all("div", {"data-test": "teaser-citation"})
                published = soup.find_all("span", {"itemprop": "datePublished"})


                publi = str(publisher[0].text)[10:]
                request.session['pb'] = publi


                published = published[0].text[-4:]

                request.session['yr'] = published


                if "and" in str(author[0].text):
                    au = str(author[0].text).replace("and", ",")
                    request.session["new_au"] = au
                else:
                    request.session["new_au"] = str(author[0].text)

                autho = request.session["new_au"][9:]
                if str(autho).endswith(";"):
                    new_authors = autho[:-1]
                    request.session['final_au'] = new_authors
                else:
                    new_authors = autho
                    request.session['final_au'] = new_authors
                split_author = request.session['final_au'].split(",")
                request.session['all_authors'] = split_author


                writers = []

                if len(split_author) > 1:
                    for q in split_author:
                        qnames = q.split()
                        namef = qnames[len(qnames) - 1].strip() + ", " +  qnames[0].strip()[0]

                        writers.append(namef)

                    if len(split_author) == 2:
                        names_auth = writers[0] + " & " + writers[1]
                        request.session['names_auth'] = names_auth

                    if len(split_author) > 2:
                        names2 = []

                        for j in writers:
                            jsplit = j.split()

                            jname = jsplit[0] + " " + jsplit[len(jsplit) - 1].strip()[0]+ "."
                            names2.append(jname)
                        print(names2)







                        last_names = names2[len(names2) - 2] + " & " + names2[len(names2) - 1]

                        names2.pop(len(names2) - 1)

                        names2.pop(len(names2) - 1)
                        names2.append(last_names)
                        names_many = ""
                        for p in names2:
                            names_many = names_many + p + ", "
                        names_aut = names_many


                        request.session['names_auth'] = names_aut

                if len(split_author) == 1:
                    for q in split_author:
                        qnames = q.split()
                        names_aut = qnames[len(qnames) - 1].strip() + ", " + qnames[0].strip()[0]
                        request.session['names_auth'] = names_aut

                writersm = []
                if len(split_author) > 1:
                    for qm in split_author:
                        qmnames = qm.split()
                        namefm = qmnames[0].strip() + ", " + qmnames[len(qmnames) - 1].strip()
                        writersm.append(namefm)

                    if len(split_author) == 2:
                        names_authm = writersm[0] + " & " + writersm[1]
                        request.session['names_authm'] = names_authm


                    if len(split_author) > 2:
                        names2m = []
                        for jm in writersm:
                            jsplitm = jm.split()
                            jnamem = jsplitm[len(jsplitm) - 1] + ", " + jsplitm[0].strip()+ ""
                            names2m.append(jnamem)
                        print(names2m)
                        last_namesm = names2m[len(names2m) - 2] + " & " + names2m[len(names2m) - 1]

                        names2m.pop(len(names2m) - 1)

                        names2m.pop(len(names2m) - 1)
                        names2m.append(last_namesm)
                        names_manym = ""
                        for pm in names2m:
                            names_manym = names_manym + pm + ". "
                        names_autm = names_manym
                        request.session['names_authm'] = names_autm

                if len(split_author) == 1:
                    for q in split_author:
                        qnames = q.split()
                        names_aut = qnames[len(qnames) - 1].strip() + ", " + qnames[0].strip()
                        request.session['names_authm'] = names_aut
            else:
                request.session['tt'] = ""
                request.session['all_authors'] = ""
                request.session['pb'] = ""
                request.session['yr'] = ""

            apa = request.session['names_auth'] + " . (" + request.session['yr'] + "). " + request.session[
                'tt'] + ". " + request.session['pb'] + "."

            harvard = request.session[
                          'names_auth'] + " ., " + request.session['yr'] + ". " + request.session['tt'] + ". " + \
                      request.session['pb'] + "."
            mla = request.session[
                      'names_authm'] + " . " + request.session['tt'] + "." + request.session['yr'] + ". " + \
                  request.session['pb'] + "."

            context = {"title": request.session['tt'], "year": request.session['yr'],
                       "authors": request.session['all_authors'], "pub": request.session['pb'],
                       "apa": apa,
                       "mla": mla,
                       "harvard": harvard}

            return render(request, "journal.html", context)
    except Exception as e:

        return HttpResponse("<script>alert('An error occurred. Please try again..');"
                          "window.location='/cite_journal'</script>")

    return render(request, "journal.html")


def dicti(request):
    try:
        if request.method == "POST":
            search = request.POST.get('word')
            final_url = "https://www.merriam-webster.com/dictionary/" + search
            response = requests.get(final_url)
            data = response.text
            soup = BeautifulSoup(data, features='html.parser')
            ref = soup.find_all()
            span = soup.select(".important-blue-link")
            # span2 = soup.select(".important-blue-link")
            span2 = soup.select(".dtText")

            adj = []

            for i in span2:
                adj.append(i.text)

            return render(request, "dictionary.html", {"adj": adj, "adj2": span[0].text, "search": search})
        else:
            return render(request, "dictionary.html")
    except:
        return render(request, "dictionary.html")


def watch(request):
    return render(request, "watch.html")
    

def hesgoal(request):
    try:
        final_url = "https://sportsonline.gl/prog.txt"
        req = requests.get(final_url)
        soup = BeautifulSoup(req.text, "html.parser")
        o_soup = BeautifulSoup(req.text, "html.parser")
        # q = sou
        days = ['MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY', 'SATURDAY', 'SUNDAY']
        days_in_soup = []
        days_index = []
        for i in days:
            try:
                index = str(soup).index(i.upper())
                days_in_soup.append(i)
                days_index.append(index)
            except Exception as e:
                print(e)
        n = len(days_index)
        day2 = ""
        day1 = days_in_soup[0]
        if len(days_in_soup) > 1:
            day2 = days_in_soup[1]

        day_index1 = days_index[0]
        day_index2 = 0
        if len(days_index) > 1:
            day_index2 = days_index[1]

        len_days_soup = len(days_in_soup)
        day_last = days_in_soup[len_days_soup - 1]
        len_indexes = len(days_index)
        day_index_last = days_index[len_indexes - 1]
        if len(days_in_soup) > 1:
            if (days_in_soup[0] == 'MONDAY') & (days_in_soup[1] == 'SATURDAY'):
                days_in_soup.pop(0)
                days_in_soup.append(day1)
                days_index.pop(0)
                days_index.append(day_index1)

            if (days_in_soup[0] == 'MONDAY') & (days_in_soup[1] == 'SUNDAY'):
                days_in_soup.pop(0)
                days_in_soup.append(day1)
                days_index.pop(0)
                days_index.append(day_index1)

            if (days_in_soup[0] == 'MONDAY') & (days_in_soup[len_days_soup - 1] == 'SUNDAY'):
                days_in_soup.pop(len_days_soup - 1)
                days_in_soup.insert(0, "SUNDAY")
                days_index.pop(len_indexes - 1)
                days_index.insert(0, day_index_last)

        if (n >= 2):
            soup = str(soup)[0:days_index[1]]
        start_str = []
        result = re.findall(r'\s(\d{2}\:\d{2}\s?)', str(soup))
        counter = 0
        for i in result:
            item = str(i).strip() + str(counter) + ":*"

            start_str.append(item)
            counter = counter + 1
        # print(start_str)
        # print(soup)
        index = 0
        new_soup = soup
        for i in start_str:
            new_soup = str(new_soup).replace(str(result[index]), i, 1)
            # print("NEW SOUP: "+str(index)+" "+new_soup)
            index = index + 1
        # print(new_soup)
        arr = []
        indixes = []
        # print(new_soup)

        for i in start_str:
            index0 = str(new_soup).index(i)
            indixes.append(index0)

            # start_str = str(soup).replace(i.strip(),"*m*")

        # return HttpResponse("hey"+result[p.select('tr')
        # print(len(indixes))
        for i in indixes:
            index0 = i
            index1 = len(str(new_soup))
            try:
                index1 = indixes[(indixes.index(i) + 1)]
            except:
                index1 = len(str(new_soup))
            # print(str(index0)+":"+str(index1))
            item = str(new_soup)[index0:index1]
            arr.append(item)
        final_arr = []
        # print(arr)
        for i in arr:
            try:
                time = i[0:5]
                hour = time[0:2]

                j = i.index(":*") + 2
                k = i.index("|")
                q = i.index("|") + 1
                url = i[q:]
                title = i[j:k]
                son = '{"url":"' + url.strip() + '","time":"' + time + '","title":"' + title.strip() + '"}'

                jso = json.loads(son, strict=False)
                # print(son)
                final_arr.append(jso)
            except:
                pass
        # soup 2 array 2
        soup2 = ""
        if len(days_index) == 2:
            soup2 = str(o_soup)[days_index[1]:len(str(o_soup))]
        elif len(days_index) == 1:
            if len(days_index) == 2:
                soup2 = str(o_soup)[days_index[0]:len(str(o_soup))]
        else:
            soup2 = str(o_soup)[days_index[1]:days_index[2]]

        # print(soup2)

        start_str_arr2 = []
        result_arr2 = re.findall(r'\s(\d{2}\:\d{2}\s?)', str(soup2))
        counter_arr2 = 0
        for i in result_arr2:
            item = str(i).strip() + str(counter_arr2) + ":*"

            start_str_arr2.append(item)
            counter_arr2 = counter_arr2 + 1
        # print(start_str)
        index_arr2 = 0
        new_soup_arr2 = soup2
        for i in start_str_arr2:
            new_soup_arr2 = str(new_soup_arr2).replace(str(result_arr2[index_arr2]), i, 1)
            # print("NEW SOUP: "+str(index)+" "+new_soup)
            index_arr2 = index_arr2 + 1
        arr2 = []
        indixes_arr2 = []

        for i in start_str_arr2:
            index0 = str(new_soup_arr2).index(i)
            indixes_arr2.append(index0)

            # start_str = str(soup).replace(i.strip(),"*m*")

        # return HttpResponse("hey"+result[p.select('tr')
        # print(len(indixes))
        for i in indixes_arr2:
            index0 = i
            index1 = len(str(new_soup_arr2))
            try:
                index1 = indixes_arr2[(indixes_arr2.index(i) + 1)]
            except:
                index1 = len(str(new_soup_arr2))
            # print(str(index0)+":"+str(index1))
            item = str(new_soup_arr2)[index0:index1]
            arr2.append(item)
        final_arr2 = []
        for i in arr2:
            try:
                time = i[0:5]

                j = i.index(":*") + 2
                k = i.index("|")
                q = i.index("|") + 1
                url = i[q:]
                title = i[j:k]
                son = '{"url":"' + url.strip() + '","time":"' + time + '","title":"' + title.strip() + '"}'

                jso = json.loads(son, strict=False)

                final_arr2.append(jso)
            except Exception as e:
                print(e)
        if len(days_in_soup) > 1:
            return render(request, "hesgoal.html",
                          {"syn": final_arr, "syn2": final_arr2, "day1": days_in_soup[0], "day2": days_in_soup[1]})
        else:
            return render(request, "hesgoal.html", {"syn": final_arr, "syn2": final_arr2, "day1": days_in_soup[0]})
        # return HttpResponse(final_arr2)
    except:
        subject = "STANSOFT SPORTS: ERROR"
        to_email = "sirstanleyzurki@gmail.com"
        message = "Hello Dragon,\nYou have an error!!!!"
        send_mail(subject, message, EMAIL_HOST_USER, [to_email], fail_silently=False)
        response = '{"success":"Success"}'
        return render(request, "errors.html")