from mnfapp.views import base, languages as lang
import re
from django.contrib import messages
from MNF.settings import BasePath, COUNTRY_KEY, EMAIL_HOST_USER
from mnfapp.models import MNFScriptDatabase
from mnfapp.models import SampleScript, PaymentData
from datetime import date
import pandas as pd
import time

# from mnfapp.views import PaymentDetails
# from scriptAudit.script_audit_codes.script_audit import do_script_audit
# from neutralAudit.mnf_script_audit_v8 import call_script_audit_for_conversion
# from neutralAudit.views import audit1
from payment.models import conversionPayment, privilegedUser1
from forex_python.converter import CurrencyRates
from mnfapp.models import *
from users.models import *
import stripe
from django.shortcuts import redirect
from PyPDF2 import PdfFileReader, PdfFileWriter
from .forms import CScript, SScript, AScript
from .models import UploadScript, StoryConversion, BookConversion, pptconversion
from MNF.settings import (
    BasePath,
    YEARLY_MEMBER_ADDITIONAL,
    RUNNING_DISCOUNT_CONVERSION,
    STRIPE_SECRET_KEY,
    STRIPE_PUBLISHABLE_KEY,
    RAZORPAY_KEY_ID,
    RAZORPAY_KEY_SECRET,
    CONVERSION_PER_PAGE,
    STRIPE_PLATFORM_FEE,
    RAZORPAY_PLATFORM_FEE,
    LIFE_MEMBER_ADDITIONAL,
    EMPLOY_DISCOUNT,
    LPP_PER_PAGE,
)
import subprocess
from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from .translation.detection import getInputs, script_det, language_detector
import random
from googletrans import Translator
from subprocess import Popen
from pptx import Presentation

# from conversion.translation import final_translation
from conversion.translation.twostepconversion import translate_function
from mnfapp.models import MNFScriptDatabase, Notifications
from ideamall.views import sendemail
from page_script.models import MNFScriptDatabase_2, Conversions, Conversion_link
from django.contrib.auth.decorators import login_required
from pymongo import MongoClient
from django.core.mail import EmailMessage
from django.conf import settings
from django.http import HttpResponse, JsonResponse, HttpResponseRedirect
from pathlib import Path
from django.core.files.storage import FileSystemStorage
from django.core.mail import EmailMultiAlternatives
from django.template.loader import render_to_string
from django.utils.html import strip_tags
import os
import datetime
import razorpay
from pytz import timezone
from django.contrib.auth.models import User
from .booktranslator.newConvertBook import convert_books

# from .storytranslator.trans import convert_story
from lpp.views import task_assigner
from lpp.models import LPPTASKDatabase
import threading
from threading import Thread

# ppt convert

from conversion.ppt_translation.final_srt_ppt import translate_presentation
from page_script.views import service_update_internal

BASE_DIR = Path(__file__).resolve().parent.parent
basePath = BasePath()


# This is your real test secret API key.
# stripe.api_key = "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"
# stripe.api_key = "sk_test_51JT8ahSF9vzGWnggJT1M69LDT0Q8tCqvHzuWd9Fih5YO2guIpMpUd58swbDrJYocpQZAn3nY8k3Ymyw8QZ8dLeEF00VxfBmMWI"
stripe.api_key = STRIPE_SECRET_KEY
# STRIPE_PUB_KEY ="pk_test_51JT8ahSF9vzGWngg9ik0jueTIilHhCQomixBFOiNzCuo4Wwc5oRm73d05vdcboMgNwhyNcNTa2si8idqbB5msvwe006q3S96tM"
# STRIPE_PUB_KEY ="pk_live_51JT8ahSF9vzGWngg4N8fwhTPk5jq8fqBFdokqSMe7AVaOvH6BdyTwAfAoY79qkeJTFA0OdT5qkAk2FCNWCu6W9l000STNnHa7H"
STRIPE_PUB_KEY = STRIPE_PUBLISHABLE_KEY
keyID = RAZORPAY_KEY_ID
keySecret = RAZORPAY_KEY_SECRET
languages = {
    "hi": "Hindi",
    "en": "English",
    "ur": "Urdu",
    "ar": "Arabic",
    "bn": "Bengali",
    "kn": "Kannada",
    "ta": "Tamil",
    "bg": "Bulgarian",
    "bn": "Bengali",
    "ml": "Malayalam",
    "ru": "Russian",
    "sr": "Serbian",
    "uk": "Ukranian",
    "hr": "Croatian",
    "ga": "Irish",
    "sq": "Albanian",
    "mr": "Marathi",
    "fa": "Persian",
    "te": "Telugu",
    "tr": "Turkish",
    "hu": "Hungarian",
    "it": "Italian",
    "ro": "Romanian",
    "pa": "Punjabi",
    "gu": "Gujarati",
    "or": "Oriya",
    "zh-CN": "Chinese-Simplified",
    "zh-TW": "Chinese-Traditional",
    "ne": "Nepali",
    "fr": "French",
    "es": "Spanish",
    "id": "Indonesian",
    "el": "Greek",
    "ja": "Japanese",
    "jv": "Javanese",
    "ko": "Korean",
    "be": "Belarusian",
    "uz": "Uzbek",
    "sd": "Sindhi",
    "af": "Afrikaans",
    "de": "German",
    "is": "Icelandic",
    "ig": "Igbo",
    "la": "Latin",
    "pt": "Portugese",
    "my": "Myanmar",
    "th": "Thai",
    "su": "Sundanese",
    "lo": "Lao",
    "am": "amharic",
    "si": "Sinhala",
    "az": "Azerbaijani",
    "kk": "Kazakh",
    "mk": "Macedonian",
    "bs": "Bosnian",
    "ps": "Pashto",
    "mg": "Malagasy",
    "ms": "Malay",
    "yo": "Yoruba",
    "cs": "Czech",
    "da": "Danish",
    "nl": "Dutch",
    "tl": "Tagalog",
    "no": "Norwegian",
    "sl": "Slovenian",
    "sv": " Swedish",
    "vi": "Vietnamese",
    "cy": "Welsh",
    "he": "Hebrew",
    "hy": "Armenian",
    "km": "Khmer",
    "ka": "Georgian",
    "mn": "Mongolian",
    "ku": "Kurdish",
    "ky": "Kyrgyz",
    "tk": "Turkmen",
    "fi": "Finnish",
    "ht": "Haitian Creole",
    "haw": "Hawaiian",
    "lt": "Lithuanian",
    "lb": "Luxembourgish",
    "mt": "Maltese",
    "pl": "Polish",
    "eo": "Esperanto",
    "tt": "Tatar",
    "ug": "Uyghur",
    "ha": "Hausa",
    "so": "Somali",
    "sw": "Swahili",
    "yi": "Yiddish",
    "eu": "Basque",
    "ca": "Catalan",
    "ceb": "Cebuano",
    "co": "Corsican",
    "et": "Estonian",
    "fy": "Frisian",
    "gl": "Galician",
    "hmn": "Hmong",
    "rw": "Kinyarwanda",
    "lv": "Latvian",
    "mi": "Maori",
    "sm": "Samoan",
    "gd": "Scots Gaelic",
    "st": "Sesotho",
    "sn": "Shona",
    "sk": "Slovak",
    "xh": "Xhosa",
    "zu": "Zulu",
}


# -> For Testing of Conversion
def run_testing(request):
    from conversion.translation.testing_scripts import test_run

    # from conversion.translation.testing_scripts_mini import test_run
    from threading import Thread

    # create a thread
    thread = Thread(target=test_run)
    # run the thread
    thread.start()
    # wait for the thread to finish
    print("Waiting for the thread...")
    thread.join()
    # test_run()
    return render(request, "conversion/testing.html")


# -> Converting Docx to PDF
def convert_to_pdf(input_docx, out_folder):
    p = subprocess.Popen(
        [
            "libreoffice",
            "--headless",
            "--convert-to",
            "pdf",
            "--outdir",
            out_folder,
            input_docx,
        ]
    )
    print(["--convert-to", "pdf", input_docx])
    p.communicate()


# -> Countimg Number of Pages
def countPages(docfile, pdfname):
    convert_to_pdf(docfile, rf"{basePath}/media/PdfFiles/")
    pdf = PdfFileReader(open(rf"{basePath}/media/PdfFiles/{pdfname}", "rb"))
    number_of_pages = pdf.getNumPages()
    return number_of_pages


# -> Initital Saving of Script in database and extracting various languages present in that
def conversion(request):
    print("Entered Conversion Function")
    sampleList = SampleScript.objects.all()
    with open(f"{basePath}/MNF/json_keys/language_pairs.json") as c:
        language_pairs = json.load(c)
    with open(f"{basePath}/MNF/json_keys/default_script.json") as c:
        default_script = json.load(c)
    with open(f"{basePath}/MNF/json_keys/script_pairs.json") as c:
        script_pairs = json.load(c)
    if request.method == "POST":
        M = MNFScriptDatabase()
        UScript = CScript(request.POST, request.FILES)
        if UScript.is_valid():
            M.script = UScript.cleaned_data.get("script")
            M.save()
            author_name = str(request.user.username)
            script_title = M.script.name
            numPages = countPages(
                str(BASE_DIR) + "/media/" +
                script_title, script_title[8:-4] + "pdf"
            )
            MyURL = "/media/" + str(script_title)
            formInput = getInputs(str(BASE_DIR) + MyURL)
            dial_src_script = formInput[2]
            dial_src_lang = formInput[1]
            non_dial_src_lang = formInput[0]
            non_dial_src_script = formInput[3]
            option3 = formInput[4]
            option4 = formInput[5]
            option5 = formInput[6]
            option6 = formInput[7]
            print("The Data of formInput is:", formInput)
            context = {
                "id": M.id,
                "numPages": numPages,
                "fileName": MyURL,
                "non_dial_src_script": non_dial_src_script,
                "author_name": author_name,
                "script_title": script_title,
                "UScript": UScript,
                "dial_src_script": dial_src_script,
                "dial_src_lang": dial_src_lang,
                "dial_src_lang_full": languages.get(dial_src_lang),
                "non_dial_src_lang_full": languages.get(non_dial_src_lang),
                "non_dial_src_lang": non_dial_src_lang,
                "list": sampleList,
                "option3": option3,
                "option4": option4,
                "option5": option5,
                "option6": option6,
                "language_pairs": language_pairs,
                "default_script": default_script,
                "script_pairs": script_pairs,
            }

            return render(request, "conversion/conversion.html", context)
    return render(
        request,
        "conversion/conversion.html",
        {
            "list": sampleList,
            "language_pairs": language_pairs,
            "default_script": default_script,
            "script_pairs": script_pairs,
        },
    )


# -> At 10sec intervals check if conversion completed
def is_converted(request):
    script_id = request.GET["script_id"]
    if request.GET["centralised"] == "yes":
        z = Conversion_link.objects.get(
            script_name=MNFScriptDatabase_2.objects.get(script_id=script_id)
        )
        objs = z.conversions.all()
        for indx, obji in enumerate(objs):
            if indx == len(objs) - 1:
                obj = obji
            else:
                pass
    else:
        obj = MNFScriptDatabase.objects.get(script_id=script_id)
    print("obj.script convetred function", obj.translated_script_path)
    if obj.translated_script_path:
        return JsonResponse({"status": "success"}, status=200)
    else:
        return JsonResponse({"status": "pending"}, status=202)


# -> Actually Running Translation and Transliteration of script
def make_conversion(request):
    print("MAke Conversion mein hu")
    script_file_path = request.GET["script_file_path"]
    request_id = request.GET["request_id"]
    str1 = str(script_file_path)
    if str1[41:45] == "user":
        script_file_path = "/home/" + str(str1[41:])
    script_id = request.GET["script_id"]
    dial_conv_script = request.GET["dial_conv_script"]
    dial_src_lang = request.GET["dial_src_lang"]
    non_dial_src_lang = request.GET["non_dial_src_lang"]
    dial_src_script = request.GET["dial_src_script"]
    restrict_to_five = request.GET["restrict_to_five"]
    option3 = request.GET.get("option3")
    option4 = request.GET.get("option4")
    option5 = request.GET.get("option5")
    option6 = request.GET.get("option6")

    if request.GET["centralised"] == "yes":
        service_update_internal(script_id, request_id,
                                "Conversion", "20% Completed")
        z = Conversion_link.objects.get(
            script_name=MNFScriptDatabase_2.objects.get(script_id=script_id)
        )
        objs = z.conversions.all()
        for indx, obji in enumerate(objs):
            if indx == len(objs) - 1:
                obj = obji
            else:
                pass
        script_file_path = str(basePath) + script_file_path
        script_title = str(
            MNFScriptDatabase_2.objects.get(script_id=script_id).script_name
        )
        dial_dest_lang = obj.dial_dest_language
        dial_dest_script = obj.dial_dest_script
        non_dial_dest_lang = obj.nondial_dest_language
        dual_dial_script = obj.dual_dial_script  # Yes,No

    else:
        user_script_data = MNFScriptDatabase.objects.get(script_id=script_id)
        script_title = user_script_data.script_title
        dial_dest_lang = user_script_data.dial_dest_language
        dial_dest_script = user_script_data.dial_dest_script
        non_dial_dest_lang = user_script_data.nondial_dest_language
        dual_dial_script = user_script_data.dual_dial_script  # Yes,No

    print("Conversion Translation is Starting")
    print(
        rf'translate_function("{script_file_path}", "{script_id}", "{dial_conv_script}", "{dial_src_lang}","{non_dial_src_lang}", "{dial_src_script}", "{restrict_to_five}", "{option3}", "{option4}", "{option5}", "{option6}")'
    )

    if request.GET["centralised"] == "yes":

        service_update_internal(script_id, request_id,
                                "Conversion", "30% Completed")
        pass
    # try:
    translate_function(
        script_file_path,
        script_id,
        dial_src_lang,
        non_dial_src_lang,
        dial_src_script,
        restrict_to_five,
        option3,
        option4,
        option5,
        option6,
        request.GET["centralised"],
    )

    if request.GET["centralised"] == "yes":
        service_update_internal(script_id, request_id,
                                "Conversion", "90% Completed")
        pass

    if request.GET.get("to_be_vetted_by_lpp") == "on":
        if request.POST.get("centralised") == "yes":
            # Vetting is not allowed from Page_script conversions
            pass
        else:
            obj = MNFScriptDatabase.objects.get(script_id=script_id)
            X = LPPTASKDatabase()
            X.user_id = obj.user_id
            X.usernote = "Kindly check if the translated file is correct as per the Uploaded Document!"
            X.translated_script = obj
            X.generated_from = "conversion"
            temp_amount = (
                (request.session["onlylppfee"])
                * request.session["team_discount"]
                * request.session["member_discount"]
                * request.session["running_discount"]
            )
            X.amoutgiventolpp_action = round((temp_amount / 2), 2)
            X.amoutgiventolpp_dialogue = round((temp_amount / 2), 2)
            X.save()
            task_assigner(int(X.task_id), "conversion")

    print("Script Translated successfully and Sent for Vetting if chosen")
    if request.GET["centralised"] == "yes":
        pass
        service_update_internal(script_id, request_id,
                                "Conversion", "Completed")
    user = request.user
    subject = "Conversion Generated Successfully " + "."
    from_email = EMAIL_HOST_USER
    to = request.user.email
    response = redirect("narration").url
    path = request.build_absolute_uri(response)
    context = {
        # "Name": user,
        "script_id": script_id,
        "script_name": script_title,
        "dual_dial": dual_dial_script,
        "dial_src_lang": dial_src_script,
        "dial_dest_lang": languages.get(dial_dest_lang),
        "non_dial_dest_lang": languages.get(non_dial_dest_lang),
        "non_dial_src_lang": languages.get(non_dial_src_lang),
        "dial_dest_script": dial_dest_script,
        "status": "Success",
        "path": path,
    }
    html_content = render_to_string(
        "conversion/email.html", context
    )  # render with dynamic value
    print(html_content, "this is a html content ****************** ")
    # Strip the html tag. So people can see the pure text at least.
    text_content = strip_tags(html_content)
    # create the email, and attach the HTML version as well.
    print("email process started")
    msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
    msg.attach_alternative(html_content, "text/html")
    msg.send()
    print("after mail has been sent my context is", context)
    return JsonResponse(context, status=200)
    # except Exception as e:

    #     print("Error:", e)
    #     print(
    #         "Script translation failed due to some internal error. If you have made any payment for conversion that will be refunded"
    #     )
    #     payment_intent_id = user_script_data.payment_intent_id
    #     print(
    #         "translated script file path in except",
    #         user_script_data.translated_script_path
    #     )
    #     if request.POST.get("centralised") == "yes":
    #         obj = MNFScriptDatabase_2.objects.get(script_id=script_id)
    #     else:
    #         obj = MNFScriptDatabase.objects.get(script_id=script_id)
    #     print("obj.script converted function", obj.translated_script_path)

    #     if payment_intent_id:
    #         if payment_intent_id[0:4] == "pay":
    #             client = razorpay.Client(auth=(keyID, keySecret))
    #             payment_id = payment_intent_id
    #             paydetail = client.payment.fetch(payment_id)
    #             total_amount = request.POST.get(
    #                 "total_amount") - (paydetail["fee"] / 100)
    #             with open(f'{basePath}/MNF/json_keys/conversionRates.json') as c:
    #                 curr = json.load(c)
    #                 print(curr['rates']['INR'])
    #                 try:
    #                     rate = curr['rates']['INR']
    #                     print(rate, " : Latest rates 30sep")
    #                     # c = CurrencyRates()
    #                     # rate = c.get_rate("USD", str(currency.upper()))
    #                 except Exception as e:
    #                     print("checkout error", e)
    #                     rate = 80

    #             payment_amount = int(float(total_amount) * 100 * rate)
    #             client.payment.refund(
    #                 payment_id, {"amount": payment_amount, "speed": "normal", })
    #         else:
    #             stripe.Refund.create(payment_intent_id)
    #     return JsonResponse({}, status=505)


# -> For Viewing Your Conversion
@login_required
def view_conversion(request):
    ppt = pptconversion.objects.filter(
        user_id=request.user.id).order_by("-date_at")
    ppt_all = pptconversion.objects.filter(user_id=request.user.id).count()
    number = ReferUser.objects.filter(reffered_by=request.user).count()
    obj = MNFScriptDatabase.objects.filter(
        user_id=request.user).order_by("-date_at")

    script_path = []
    pq = 0
    for i in obj:
        if i.translated_script_path != "":
            script_path.append(i.translated_script_path)
            pq += 1

    script_is_vetted = []
    tasks = LPPTASKDatabase.objects.filter(user_id=request.user)
    for script in obj:
        script_is_vetted.append({"0": "0", "1": "", "2": script})
        for task in tasks:
            if task.translated_script:
                if script.script_id == task.translated_script.script_id:
                    script_is_vetted[-1]["0"] = "1"
                    script_is_vetted[-1]["1"] = task.outputfile

    lenV = len(script_path)
    countOfScript = len(script_is_vetted)
    return render(
        request,
        "conversion/stored_conversions.html",
        {
            "script_path": obj,
            "pq": pq,
            "number": number,
            "vettdata": script_is_vetted,
            "totalScript": countOfScript,
            "ppt": ppt,
            "ppt_all": ppt_all,
        },
    )


# -> For Deleting your Conversion
def delete_script(request, id):
    MNFScriptDatabase.objects.get(id=id).delete()
    return HttpResponseRedirect("/conversion/view_conversion")


# -> Feedback on Conversion by User
def feedback_user(request):
    if request.method == "POST":
        x = MNFScriptDatabase.objects.get(id=request.POST.get("mnfscriptid"))
        if str(request.POST.get("text")) == " " or str(request.POST.get("text")) == "":
            x.attention_feedback = ""
        else:
            x.attention_feedback = str(request.POST.get("text"))
        if str(request.POST.get("text2")) == " " or str(request.POST.get("text2")) == "":
            x.error_faced_feedback = ""
        else:
            x.error_faced_feedback = str(request.POST.get("text2"))
        if str(request.POST.get("text3")) == " " or str(request.POST.get("text3")) == "":
            x.improvement_feedback = ""
        else:
            x.improvement_feedback = str(request.POST.get("text3"))
        if request.POST.get("rating") == " " or request.POST.get("rating") == "":
            x.exp_rate = 0
        else:
            x.exp_rate = int(request.POST.get("rating"))
        if request.POST.get("rating2") == " " or request.POST.get("rating2") == "":
            x.content_accuracy_rate = 0
        else:
            x.content_accuracy_rate = int(request.POST.get("rating2"))
        if request.POST.get("rating3") == " " or request.POST.get("rating3") == "":
            x.translation_accuracy_rate = 0
        else:
            x.translation_accuracy_rate = int(request.POST.get("rating3"))
        x.save()
        return redirect("view_conversion")


# -> For Demo of Conversion
def demo(request):
    number = ReferUser.objects.filter(reffered_by=request.user).count()
    return render(request, "conversion/demo.html", {"number": number})


# -> Some Random Function
def announce(request):
    message = ""
    user = User.objects.all()
    cUser = request.user
    if cUser.is_superuser == True:
        if request.method == "POST":
            notification = request.POST.get("message")
            for i in user:
                var = Notifications(user_id=i, notification=notification)
                var.save()
            messgae = "notification sent successfull."
            return render(request, "conversion/announce.html", {"message": message})
        else:
            return render(request, "conversion/announce.html", {})
    else:
        message = " you need to be superuser"
        return render(request, "conversion/announce.html", {"message": message})


# -> Conversion Checkout
def conversionCheckout(request):
    if request.method == "POST":
        if request.POST.get("want_to_be_vetted") == "yes":
            total_amount = request.session["amount"]
            amount_lpp_without_discount = request.session["onlylppfee"]
            print(request.session["amount"], " : Final Amount")
            request.session["want_to_be_vetted"] = "on"
        else:
            total_amount = request.session["amount"]
            request.session["want_to_be_vetted"] = request.POST.get(
                "want_to_be_vetted")
        request.session["interested_to_be_lpp"] = request.POST.get(
            "interested_to_be_lpp"
        )
        if request.POST["pay_with_wallet"] == "yes":
            with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
                curr = json.load(c)
                print(curr["rates"]["INR"])
                try:
                    rate = curr["rates"]["INR"]
                except Exception as e:
                    print("checkout error", e)
                    rate = 80
            balance = float(request.POST["balance"])
            payable = float(request.POST["payable"])
            wall = Wallet.objects.get(user=request.user)
            request.session["fbalance"] = wall.balance - (balance*rate)
            wall.save()
            request.session["amount"] = payable
            total_amount = request.session["amount"]
        if request.POST.get("country") == "IN":

            # try: -> Old WAy of Getting Conversion Rates between Currencies
            #     c = CurrencyRates()
            #     rate = c.get_rate("USD", "INR")
            # except:
            #     rate = 80
            with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
                curr = json.load(c)
                print(curr["rates"]["INR"])
                try:
                    rate = curr["rates"]["INR"]
                    print(rate, " : Latest rates 30sep")
                    # c = CurrencyRates()
                    # rate = c.get_rate("USD", str(currency.upper()))
                except Exception as e:
                    print("checkout error", e)
                    rate = 80

            amtINR = round(float(float(total_amount) * rate), 2)
            client = razorpay.Client(auth=(keyID, keySecret))
            payment_intent = client.order.create(
                {
                    "amount": int(float(total_amount) * 100 * rate),
                    "currency": "INR",
                    "payment": {
                        "capture": "automatic",
                        "capture_options": {"refund_speed": "normal"},
                    },
                }
            )
            request.session["CurrencyRate"] = rate
            pid = payment_intent["id"]
            context = {
                "pk": keyID,
                "amtINR": amtINR,
                "pid": pid,
                "amount": total_amount,
            }
            return render(request, "conversion/checkoutC_RazorPay.html", context)

        else:

            # try: -> Old WAy of Getting Conversion Rates between Currencies
            #     c = CurrencyRates()
            #     rate = c.get_rate("USD", "INR")
            # except:
            #     rate = 80
            with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
                curr = json.load(c)
                print(curr["rates"]["INR"])
                try:
                    rate = curr["rates"]["INR"]
                    print(rate, " : Latest rates 30sep")
                    # c = CurrencyRates()
                    # rate = c.get_rate("USD", str(currency.upper()))
                except Exception as e:
                    print("checkout error", e)
                    rate = 80

            amtINR = round(float(float(total_amount) * rate), 2)
            payment_intent = stripe.PaymentIntent.create(
                amount=int(float(total_amount) * 100 * rate),
                currency="INR",
                payment_method_types=["card"],
            )
            request.session["CurrencyRate"] = rate
            request.session["payment_intent_id"] = payment_intent.id
            context = {
                "pk": STRIPE_PUB_KEY,
                "total_amount": total_amount,
                "amtINR": amtINR,
            }
            return render(request, "conversion/checkoutC.html", context)
    return render(request, "conversion/conversion.html")


# ppt checkout
# -> Conversion Checkout


def pptCheckout(request):
    if request.method == "POST":
        if request.POST.get("want_to_be_vetted") == "yes":
            total_amount = request.session["pptamount"]
            request.session["want_to_be_vetted"] = "on"
        else:
            total_amount = request.session["pptamount"]
            request.session["want_to_be_vetted"] = "off"

        if request.POST["pay_with_wallet"] == "yes":
            with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
                curr = json.load(c)
                print(curr["rates"]["INR"])
                try:
                    rate = curr["rates"]["INR"]
                except Exception as e:
                    print("checkout error", e)
                    rate = 80
            balance = float(request.POST["balance"])
            payable = float(request.POST["payable"])
            wall = Wallet.objects.get(user=request.user)
            request.session["fbalance"] = wall.balance - (balance*rate)
            wall.save()
            request.session["amount"] = payable
            total_amount = request.session["amount"]

        if request.POST.get("country") == "IN":

            # try: -> Old WAy of Getting Conversion Rates between Currencies
            #     c = CurrencyRates()
            #     rate = c.get_rate("USD", "INR")
            # except:
            #     rate = 80
            with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
                curr = json.load(c)
                print(curr["rates"]["INR"])
                try:
                    rate = curr["rates"]["INR"]
                    print(rate, " : Latest rates 30sep")
                    # c = CurrencyRates()
                    # rate = c.get_rate("USD", str(currency.upper()))
                except Exception as e:
                    print("checkout error", e)
                    rate = 80

            amtINR = round(float(float(total_amount) * rate), 2)
            client = razorpay.Client(auth=(keyID, keySecret))
            payment_intent = client.order.create(
                {
                    "amount": int(float(total_amount) * 100 * rate),
                    "currency": "INR",
                    "payment": {
                        "capture": "automatic",
                        "capture_options": {"refund_speed": "normal"},
                    },
                }
            )
            request.session["CurrencyRate"] = rate
            pid = payment_intent["id"]
            context = {
                "pk": keyID,
                "amtINR": amtINR,
                "pid": pid,
                "amount": total_amount,
            }
            return render(request, "conversion/checkoutPPT_RazorPay.html", context)

        else:

            # try: -> Old WAy of Getting Conversion Rates between Currencies
            #     c = CurrencyRates()
            #     rate = c.get_rate("USD", "INR")
            # except:
            #     rate = 80
            with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
                curr = json.load(c)
                print(curr["rates"]["INR"])
                try:
                    rate = curr["rates"]["INR"]
                    print(rate, " : Latest rates 30sep")
                    # c = CurrencyRates()
                    # rate = c.get_rate("USD", str(currency.upper()))
                except Exception as e:
                    print("checkout error", e)
                    rate = 80

            amtINR = round(float(float(total_amount) * rate), 2)
            payment_intent = stripe.PaymentIntent.create(
                amount=int(float(total_amount) * 100 * rate),
                currency="INR",
                payment_method_types=["card"],
            )
            request.session["CurrencyRate"] = rate
            request.session["payment_intent_id"] = payment_intent.id
            context = {
                "pk": STRIPE_PUB_KEY,
                "total_amount": total_amount,
                "amtINR": amtINR,
            }
            return render(request, "conversion/checkoutPPT_Stripe.html", context)
    return render(request, "conversion/conversion.html")


# -> Conversion Checkout
@login_required
def conversioncard(request):
    if request.method == "POST":
        payment_method_id = request.POST["payment_method_id"]
        payment_intent_id = request.session["payment_intent_id"]

        customer = stripe.Customer.create(
            email=request.user.email,
            payment_method=payment_method_id,
            invoice_settings={"default_payment_method": payment_method_id},
        )

        stripe.PaymentIntent.modify(
            payment_intent_id, payment_method=payment_method_id, customer=customer.id
        )
        ret = stripe.PaymentIntent.confirm(payment_intent_id)
        pi = stripe.PaymentIntent.retrieve(payment_intent_id)
        if ret.status == "requires_action":
            context = {
                "pk": STRIPE_PUB_KEY,
                "payment_intent_secret": pi.client_secret,
            }
            return render(request, "conversion/3dsecuredConversion.html", context)
        return render(request, "payments/paymentdone.html")


# -> Conversion Stripe Payment Done Message
def paymentDoneC(request):

    if request.method == "POST":

        script_id = request.session["script_id"]
        script_title = request.session["script_title"]
        script_file_path = request.session["script_file_path"]
        dial_conv_script = request.session["dial_conv_script"]
        nondial_dest_language = request.session["nondial_dest_language"]
        dial_dest_language = request.session["dial_dest_language"]
        dial_dest_script = request.session["dial_dest_script"]
        dial_src_lang = request.session["dial_src_lang"]
        non_dial_src_lang = request.session["non_dial_src_lang"]
        dial_src_script = request.session["dial_src_script"]
        non_dial_src_script = request.session["non_dial_src_script"]
        dual_dial_script = request.session["dual_dial_script"]
        if request.session.get("want_to_be_vetted"):
            total_amount = request.session["lppamount"]
        else:
            total_amount = request.session["amount"]
        to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
        option3 = request.session["option3"]
        option4 = request.session["option4"]
        option5 = request.session["option5"]
        option6 = request.session["option6"]
        payment_intent_id = request.session["payment_intent_id"]
        pi = stripe.PaymentIntent.retrieve(payment_intent_id)

        if pi.status == "succeeded":

            if Wallet.objects.filter(user=request.user).exists():
                wall = Wallet.objects.get(user=request.user)
                wall.balance = request.session["fbalance"]
                wall.save()

            c = conversionPayment()
            s = MNFScriptDatabase()
            s.user_id = request.user
            s.script_id = script_id
            s.script_title = script_title
            s.author_name = request.user.first_name
            s.dial_dest_language = dial_dest_language
            s.dial_dest_script = dial_dest_script
            s.nondial_dest_language = nondial_dest_language
            s.dual_dial_script = dual_dial_script
            s.script_file_path = script_file_path
            s.payment_intent_id = payment_intent_id
            s.nondial_src_script = non_dial_src_script
            s.dial_src_script = dial_src_script
            s.dial_src_language = dial_src_lang
            s.nondial_src_language = non_dial_src_lang
            s.save()

            # -----------Adding Details to payment Details--------------------------
            currencyrate = request.session["CurrencyRate"]
            user_id = request.user
            payment_id = payment_intent_id
            services_used = "Conversion"
            script_info = s
            number_of_pages = request.session["numPages"]
            total_amounts = round(
                (request.session["numPages"] *
                 CONVERSION_PER_PAGE * currencyrate),
                2,
            )
            discount = round((request.session["discount"] * currencyrate), 2)
            amount_charged = round((total_amount * currencyrate), 2)
            gateway_fee = round(
                ((STRIPE_PLATFORM_FEE / 100) * amount_charged), 2)
            currency = "INR"
            pay_method = "Card"
            payment_status = "Success"
            payment_gateway = "Stripe"
            PaymentData.objects.create(
                user_id=user_id,
                services_used=services_used,
                payment_id=payment_id,
                script_info=script_info,
                amount_charged=amount_charged,
                total_amount=total_amounts,
                number_of_pages=number_of_pages,
                gateway_fee=gateway_fee,
                discount=discount,
                currency=currency,
                pay_method=pay_method,
                payment_status=payment_status,
                payment_gateway=payment_gateway,
            )

            # c.pid = privilegedUser1.objects.get(user= request.user)
            # c.script_title = script_title
            # c.script_id = script_id
            # c.to_be_vetted_by_lpp = to_be_vetted_by_lpp
            # c.payment_intent_id = payment_intent_id
            # c.total_amount = str(total_amount)
            # c.script_file_path = script_file_path
            # c.has_paid = 'yes'
            # c.save()
            context = {
                "script_id": script_id,
                "script_title": script_title,
                "script_file_path": script_file_path,
                "dial_conv_script": dial_conv_script,
                "nondial_dest_language": nondial_dest_language,
                "dial_dest_language": dial_dest_language,
                "dial_dest_script": dial_dest_script,
                "dial_src_lang": dial_src_lang,
                "non_dial_src_lang": non_dial_src_lang,
                "dial_src_script": dial_src_script,
                "dual_dial_script": dual_dial_script,
                "total_amount": total_amount,
                "to_be_vetted_by_lpp": to_be_vetted_by_lpp,
                "restrict_to_five": "no",
                "option3": option3,
                "option4": option4,
                "option5": option5,
                "option6": option6,
            }
            return render(request, "conversion/my_conversions.html", context)
        else:
            return render(request, "payments/failed.html")


# -> Conversion Razorpay Payment Done Message
def paymentDoneC_RazorPay(request):
    if request.method == "POST":
        script_id = request.session["script_id"]
        script_title = request.session["script_title"]
        script_file_path = request.session["script_file_path"]
        dial_conv_script = request.session["dial_conv_script"]
        nondial_dest_language = request.session["nondial_dest_language"]
        dial_dest_language = request.session["dial_dest_language"]
        dial_dest_script = request.session["dial_dest_script"]
        dial_src_lang = request.session["dial_src_lang"]
        non_dial_src_lang = request.session["non_dial_src_lang"]
        dial_src_script = request.session["dial_src_script"]
        dual_dial_script = request.session["dual_dial_script"]
        non_dial_src_script = request.session["non_dial_src_script"]
        if request.session.get("want_to_be_vetted"):
            total_amount = request.session["lppamount"]
        else:
            total_amount = request.session["amount"]
        to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
        option3 = request.session["option3"]
        option4 = request.session["option4"]
        option5 = request.session["option5"]
        option6 = request.session["option6"]
        razorpay_order_id = request.POST["razorpay_order_id"]
        razorpay_payment_id = request.POST["razorpay_payment_id"]
        razorpay_signature = request.POST["razorpay_signature"]
        client = razorpay.Client(auth=(keyID, keySecret))
        params_dict = {
            "razorpay_order_id": razorpay_order_id,
            "razorpay_payment_id": razorpay_payment_id,
            "razorpay_signature": razorpay_signature,
        }
        try:
            client.utility.verify_payment_signature(params_dict)
        except:
            return render(request, "payments/failed.html")

        if Wallet.objects.filter(user=request.user).exists():
            wall = Wallet.objects.get(user=request.user)
            wall.balance = request.session["fbalance"]
            wall.save()

        c = conversionPayment()
        s = MNFScriptDatabase()
        s.user_id = request.user
        s.script_id = script_id
        s.script_title = script_title
        s.author_name = request.user.first_name
        s.dial_dest_language = dial_dest_language
        s.dial_dest_script = dial_dest_script
        s.nondial_dest_language = nondial_dest_language
        s.dual_dial_script = dual_dial_script
        s.script_file_path = script_file_path
        s.payment_intent_id = razorpay_payment_id
        s.nondial_src_script = non_dial_src_script
        s.dial_src_script = dial_src_script
        s.dial_src_language = dial_src_lang
        s.nondial_src_language = non_dial_src_lang
        s.save()
        # c.pid = privilegedUser1.objects.get(user= request.user)
        # c.script_title = script_title
        # c.script_id = script_id
        # c.to_be_vetted_by_lpp = to_be_vetted_by_lpp
        # c.payment_intent_id = razorpay_payment_id
        # c.total_amount = str(total_amount)
        # c.script_file_path = script_file_path
        # c.has_paid = 'yes'
        # c.save()

        # payFetch = client.payment.fetch(razorpay_payment_id,({'expand[]':'card'}))
        if client.payment.fetch(razorpay_payment_id, {"expand[]": "card"}):
            pay_method = "CARD"
        else:
            pay_method = "NOTCard"
        # -----------Adding Details to payment Details--------------------------
        currencyrate = request.session["CurrencyRate"]
        user_id = request.user
        payment_id = razorpay_payment_id
        services_used = "Conversion"
        script_info = s
        total_amounts = round(
            (request.session["numPages"] * CONVERSION_PER_PAGE * currencyrate),
            2,
        )
        discount = round((request.session["discount"] * currencyrate), 2)
        amount_charged = round((total_amount * currencyrate), 2)
        gateway_fee = round(
            ((RAZORPAY_PLATFORM_FEE / 100) * amount_charged), 2)
        currency = "INR"
        # pay_method = 'NOTCard'
        payment_status = "Success"
        payment_gateway = "RazorPay"
        number_of_pages = request.session["numPages"]
        print("totalamount:", total_amounts)
        print("amountcharge:", amount_charged)
        print("discount:", discount)
        PaymentData.objects.create(
            user_id=user_id,
            payment_id=payment_id,
            total_amount=total_amounts,
            services_used=services_used,
            script_info=script_info,
            discount=discount,
            amount_charged=amount_charged,
            gateway_fee=gateway_fee,
            currency=currency,
            number_of_pages=number_of_pages,
            pay_method=pay_method,
            payment_status=payment_status,
            payment_gateway=payment_gateway,
        )

        context = {
            "script_id": script_id,
            "script_title": script_title,
            "script_file_path": script_file_path,
            "dial_conv_script": dial_conv_script,
            "nondial_dest_language": nondial_dest_language,
            "dial_dest_language": dial_dest_language,
            "dial_dest_script": dial_dest_script,
            "dial_src_lang": dial_src_lang,
            "non_dial_src_lang": non_dial_src_lang,
            "dial_src_script": dial_src_script,
            "dual_dial_script": dual_dial_script,
            "total_amount": total_amount,
            "to_be_vetted_by_lpp": to_be_vetted_by_lpp,
            "restrict_to_five": "no",
            "option3": option3,
            "option4": option4,
            "option5": option5,
            "option6": option6,
        }
        return render(request, "conversion/my_conversions.html", context)
    else:
        return render(request, "payments/failed.html")


# -> Conversion Razorpay Payment Done Message
def paymentDoneppt_RazorPay(request):
    if request.method == "POST":
        x = pptconversion.objects.get(ppt_string=request.session["pptstring"])
        if request.session.get("want_to_be_vetted") == "on":
            total_amount = x.amount
        else:
            total_amount = x.amount
        razorpay_order_id = request.POST["razorpay_order_id"]
        razorpay_payment_id = request.POST["razorpay_payment_id"]
        razorpay_signature = request.POST["razorpay_signature"]
        client = razorpay.Client(auth=(keyID, keySecret))
        params_dict = {
            "razorpay_order_id": razorpay_order_id,
            "razorpay_payment_id": razorpay_payment_id,
            "razorpay_signature": razorpay_signature,
        }
        try:
            client.utility.verify_payment_signature(params_dict)
        except:
            x.delete()
            return render(request, "payments/failed.html")

        if Wallet.objects.filter(user=request.user).exists():
            wall = Wallet.objects.get(user=request.user)
            wall.balance = request.session["fbalance"]
            wall.save()

        # payFetch = client.payment.fetch(razorpay_payment_id,({'expand[]':'card'}))
        if client.payment.fetch(razorpay_payment_id, {"expand[]": "card"}):
            pay_method = "CARD"
        else:
            pay_method = "NOTCard"
        # -----------Adding Details to payment Details--------------------------
        currencyrate = request.session["CurrencyRate"]
        user_id = request.user
        payment_id = razorpay_payment_id
        services_used = "Conversion"
        total_amounts = round(
            (x.slide_count * CONVERSION_PER_PAGE * currencyrate),
            2,
        )
        discount = round((request.session["pptdiscount"] * currencyrate), 2)
        amount_charged = round((total_amount * currencyrate), 2)
        gateway_fee = round(
            ((RAZORPAY_PLATFORM_FEE / 100) * amount_charged), 2)
        currency = "INR"
        # pay_method = 'NOTCard'
        payment_status = "Success"
        payment_gateway = "RazorPay"
        number_of_pages = x.slide_count
        print("totalamount:", total_amounts)
        print("amountcharge:", amount_charged)
        print("discount:", discount)
        PaymentData.objects.create(
            user_id=user_id,
            payment_id=payment_id,
            total_amount=total_amounts,
            services_used=services_used,
            discount=discount,
            amount_charged=amount_charged,
            gateway_fee=gateway_fee,
            currency=currency,
            number_of_pages=number_of_pages,
            pay_method=pay_method,
            payment_status=payment_status,
            payment_gateway=payment_gateway,
        )

        with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
            body = f.read()

        context_email = {
            "Date": date.today(),
            "Name": x.user_id.email,
            "emailcode": "",
            "heading1": "Thank you!",
            "heading2": " for using ppt conversion service "
            + " you will get notification whenever the conversation completes",
            "body": body,
        }
        # whomtosend, titleofmail, dateofemail, context\
        sendemail(
            x.user_id.email,
            "Thankyou for using service",
            date.today(),
            context_email,
            EMAIL_HOST_USER,
        ).start()
        # sdsdsadsadsdsadsadsdsdasdsaaaaaaassss
        ppt_conversion(x.ppt_id, request).start()
        return render(request, "conversion/thanksppt.html")
    else:
        x.delete()
        return render(request, "payments/failed.html")


# -> Conversion Stripe Payment Done Message
def paymentDoneppt_stripe(request):

    if request.method == "POST":
        x = pptconversion.objects.filter(
            ppt_string=request.session["pptstring"])

        total_amount = x.amount
        payment_intent_id = request.session["payment_intent_id"]
        try:
            pi = stripe.PaymentIntent.retrieve(payment_intent_id)
        except:
            x.delete()
            return render(request, "payments/failed.html")

        if pi.status == "succeeded":

            if Wallet.objects.filter(user=request.user).exists():
                wall = Wallet.objects.get(user=request.user)
                wall.balance = request.session["fbalance"]
                wall.save()

            # -----------Adding Details to payment Details--------------------------
            currencyrate = request.session["CurrencyRate"]
            user_id = request.user
            payment_id = payment_intent_id
            services_used = "Conversion"
            number_of_pages = x.slide_count
            total_amounts = round(
                (x.slide_count * CONVERSION_PER_PAGE * currencyrate),
                2,
            )
            discount = round(
                (request.session["pptdiscount"] * currencyrate), 2)
            amount_charged = round((total_amount * currencyrate), 2)
            gateway_fee = round(
                ((STRIPE_PLATFORM_FEE / 100) * amount_charged), 2)
            currency = "INR"
            pay_method = "Card"
            payment_status = "Success"
            payment_gateway = "Stripe"
            PaymentData.objects.create(
                user_id=user_id,
                services_used=services_used,
                payment_id=payment_id,
                amount_charged=amount_charged,
                total_amount=total_amounts,
                number_of_pages=number_of_pages,
                gateway_fee=gateway_fee,
                discount=discount,
                currency=currency,
                pay_method=pay_method,
                payment_status=payment_status,
                payment_gateway=payment_gateway,
            )

        with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
            body = f.read()

        context_email = {
            "Date": date.today(),
            "Name": x.user_id.email,
            "emailcode": "",
            "heading1": "Thank you!",
            "heading2": " for using ppt conversion service "
            + " you will get notification whenever the conversation completes",
            "body": body,
        }
        # whomtosend, titleofmail, dateofemail, context\
        sendemail(
            x.user_id.email,
            "Thankyou for using service",
            date.today(),
            context_email,
            EMAIL_HOST_USER,
        ).start()
        # sdsdsadsadsdsadsadsdsdasdsaaaaaaassss
        ppt_conversion(x.ppt_id, request).start()
        return render(request, "conversion/thanksppt.html")
    else:
        x.delete()
        return render(request, "payments/failed.html")


# # -> At 10sec intervals check if story conversion completed
# def is_story_converted(request):
#     story_id = request.GET["story_id"]
#     obj = StoryConversion.objects.get(story_id=story_id)
#     print("obj.script convetred function", obj.translated_story_docx)
#     if obj.translated_story_docx:
#         return JsonResponse({"status": "success"}, status=200)
#     else:
#         return JsonResponse({"status": "pending"}, status=202)


# # -> Actually Running Translation and Transliteration of story
# def my_story(request):

#     y = StoryConversion.objects.get(story_id=str(request.GET["story_id"]))

#     filename = basePath + "/media/" + str(y.upload_story)

#     src_lang = str(y.source_language)
#     target_lang = str(y.target_language)
#     filename_true = filename.replace("(", "")
#     filename_true2 = filename_true.replace(")", "")
#     try:
#         output = convert_story(filename_true2, src_lang, target_lang)
#         # some_translated_script_path = output
#         y.translated_story_docx = str(output)[27:]
#         y.save()
#         return JsonResponse({"status": "success"}, status=200)

#     except:
#         return JsonResponse({}, status=505)


# # -> Initital Saving of Story in database and extracting various languages present in that
# def convert_storyy(request):
#     if request.method == "POST":
#         y = StoryConversion()
#         y.user_id = request.user
#         now = datetime.datetime.now()
#         rightNow = str(now)
#         dash_splited = rightNow.split("-")
#         str1 = ""
#         for i in dash_splited:
#             str1 += str(i)
#         dash_splited1 = str1.split(" ")
#         str2 = ""
#         for i in dash_splited1:
#             str2 += str(i)
#         dash_splited2 = str2.split(":")
#         str3 = ""
#         for i in dash_splited2:
#             str3 += str(i)
#         dash_splited3 = str3.split(".")
#         str4 = dash_splited3[0]
#         y.story_id = "story_" + str(str4)
#         UScript = SScript(request.POST, request.FILES)
#         if UScript.is_valid():
#             y.upload_story = UScript.cleaned_data.get("story")
#             y.target_language = lang[request.POST.get("target_lang")]
#             y.source_language = lang[request.POST.get("src_lang")]
#             y.save()

#         return render(request, "conversion/my_stories.html", {"story_id": y.story_id})

#     return render(request, "conversion/convertStory.html")


# # -> For Viewing Your Stories
# def view_converted_stories(request):
#     number = ReferUser.objects.filter(reffered_by=request.user).count()
#     obj = StoryConversion.objects.filter(user_id=request.user).order_by("-date_at")

#     script_path = []
#     pq = 0
#     for i in obj:
#         if i.translated_story_docx != "":
#             script_path.append(i.translated_story_docx)
#             pq += 1

#     return render(
#         request,
#         "conversion/viewStory.html",
#         {"script_path": obj, "pq": pq, "number": number},
#     )


# # -> For Deleting your Story
# def delete_converted_story(request, id):
#     StoryConversion.objects.get(id=id).delete()
#     return HttpResponseRedirect("/conversion/view_converted_stories")


# -> Actually Running Translation and Transliteration of book
def my_book(request):
    print("Entering My_Book Conversion Function")
    y = BookConversion.objects.get(book_id=str(request.GET["book_id"]))
    pdf = PdfFileReader(open(basePath + "/media/" + str(y.upload_book), "rb"))
    numpages = pdf.getNumPages()
    print(numpages)
    if numpages <= 10:
        # try:

        path = (convert_books(basePath + "/media/" +
                str(y.upload_book)).split("/"))[6:]
        orig_path = ""
        for i in range(len(path)):
            if i == len(path) - 1:
                orig_path = orig_path + str(path[i])
            else:
                orig_path = orig_path + str(path[i]) + "/"
        y.translated_book_docx = str(orig_path)
        y.save()
        print("Entering My_Book Conversion Function")
        return JsonResponse({"status": "success"}, status=200)

    else:
        intermediate_pages = []

        # if numpages % 10 != 0:
        hard_pages = numpages // 10
        for i in range(hard_pages):
            page = (10 * i, 10 * (i + 1))
            intermediate_pages.append(page)
        final_pages = numpages - 10 * hard_pages

        intermediate_pages.append(
            (10 * hard_pages, 10 * hard_pages + final_pages))
        print("counter 1234")
        print(intermediate_pages)
        for page_start, page_end in intermediate_pages:

            # from PyPDF2 import PdfFileWriter, PdfFileReader
            # pdf_reader = PdfFileReader(open(filename, "rb"))
            pdf_writer1 = PdfFileWriter()
            for page in range(page_start, page_end):
                pdf_writer1.addPage(pdf.getPage(page))
            with open(
                f"/home/user/mnf/project/MNF/media/part_{page_start}_{page_end}.pdf",
                "wb",
            ) as file1:
                pdf_writer1.write(file1)

        pass


# -> At 10sec intervals check if book conversion completed
def is_book_converted(request):
    book_id = request.GET["book_id"]
    obj = StoryConversion.objects.get(story_id=book_id)
    print("book still converting", obj.translated_book_docx)
    if obj.translated_book_docx:
        return JsonResponse({"status": "success"}, status=200)
    else:
        return JsonResponse({"status": "pending"}, status=202)


# -> Initital Saving of Book in database and extracting various languages present in that
def convert_book(request):

    if request.method == "POST":
        print("Entering Convert Bok Function")

        y = BookConversion()
        y.user_id = request.user

        now = datetime.datetime.now()
        rightNow = str(now)
        dash_splited = rightNow.split("-")
        str1 = ""
        for i in dash_splited:
            str1 += str(i)
        dash_splited1 = str1.split(" ")
        str2 = ""
        for i in dash_splited1:
            str2 += str(i)
        dash_splited2 = str2.split(":")
        str3 = ""
        for i in dash_splited2:
            str3 += str(i)
        dash_splited3 = str3.split(".")
        str4 = dash_splited3[0]

        y.book_id = "book_" + str(str4)

        Book = AScript(request.POST, request.FILES)
        if Book.is_valid():

            y.upload_book = Book.cleaned_data.get("myfile")
            y.source_language = lang[request.POST.get("src_lang")]
            y.target_language = lang[request.POST.get("target_lang")]
            y.save()
        print("Exiting Convert Bok Function")
        return render(request, "conversion/my_books.html", {"book_id": y.book_id})

    return render(request, "conversion/convertBook.html")


# -> For Viewing Your Books
def view_converted_books(request):
    number = ReferUser.objects.filter(reffered_by=request.user).count()
    obj = BookConversion.objects.filter(
        user_id=request.user).order_by("-date_at")

    book_path = []
    pq = 0
    for i in obj:
        if i.translated_book_docx != "":
            book_path.append(i.translated_book_docx)
            pq += 1

    return render(
        request,
        "conversion/viewConvertedBooks.html",
        {"script_path": obj, "pq": pq, "number": number},
    )


# -> For Deleting your Book
def delete_converted_book(request, id):
    BookConversion.objects.get(id=id).delete()
    return HttpResponseRedirect("/conversion/view_converted_books")


# -> For making Translated PPT's
class ppt_conversion(threading.Thread):
    def __init__(self, ppt, request):
        self.ppt = ppt
        self.request = request
        threading.Thread.__init__(self)

    def run(self):
        # try:
        x = pptconversion.objects.get(ppt_id=self.ppt)
        presentation = Presentation(x.upload_ppt)
        t = random.randint(1, 1000)
        times = time.time()
        times = int(times)
        for key, value in languages.items():
            if value == x.target_lang:
                target = key
            if value == x.source_lang:
                source = key
        translate_presentation(presentation, source, target, x.target_script)
        translated_ppt = f"{x.user_id}-{source}-{target}-{t}-{times}.pptx"
        paths = f"{basePath}/media/ppt/converted/{translated_ppt}"
        presentation.save(paths)
        print(f"presentation convert saved {translated_ppt}")
        x.translated_ppt = translated_ppt
        x.save()

        # For Vetting
        # if request.session
        # obj = ppt.objects.get(script_id=script_id)
        print("Making Vetting Request for ppt")
        X = LPPTASKDatabase()
        X.user_id = x.user_id
        X.usernote = "Kindly check if the translated ppt file is correct as per the Uploaded PPT!"
        X.translated_ppt = x
        X.generated_from = "conversion"
        X.amoutgiventolpp_dialogue = self.request.session["lppamount_after_discount"]
        # temp_amount = ((request.session['onlylppfee']) * request.session['team_discount']
        #                 * request.session['member_discount'] * request.session['running_discount'])
        # X.amoutgiventolpp_action = round((temp_amount/2), 2)
        # X.amoutgiventolpp_dialogue = round((temp_amount/2), 2)
        X.save()
        task_assigner(int(X.task_id), "conversion_ppt")
        print("Making Vetting task Request for ppt")

        with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
            body = f.read()

        context_email = {
            "Date": date.today(),
            "Name": x.user_id.email,
            "emailcode": "",
            "heading1": "Congratulation!",
            "heading2": " your presentation is converted",
            "body": body,
        }
        # whomtosend, titleofmail, dateofemail, context\
        sendemail(
            x.user_id.email,
            "conversion complete",
            date.today(),
            context_email,
            EMAIL_HOST_USER,
        ).start()
        return True
        # except:
        #     pass
        # write refund code


def get_ppt_script(request):
    if request.method == "POST":
        df = pd.read_csv(rf"{basePath}/lpp/scripts.csv")
        lang1 = request.POST.get("language")
        print(lang1)
        if lang1 == "":
            lang1 = "English"
        print(lang1, " : languages :: types : ", type(lang1))

        list1_d = df.loc[df[lang1] == "D", "Script"].tolist()
        print("Bakery 20.1: ", list1_d)
        return JsonResponse({"data": list1_d})


# -> Initital Saving of PPT in database and extracting various languages present in that
def pptcovert(request):
    print("Entered ConversionFunction")
    # print("MY base path is " ,str(BASE_DIR))
    if request.method == "POST":
        x = pptconversion()
        x.ppt_string = str(time.time()) + "-ppt"
        MyURL = ""
        dial_src_script = ""
        non_dial_src_lang = ""
        non_dial_src_script = ""
        script_title = ""
        author_name = ""
        numPages = 0
        context = {}
        print("pptuploadedfn")
        user_id = request.user
        x.upload_ppt = request.FILES.get("script")
        x.user_id = request.user
        request.session["pptstring"] = x.ppt_string
        author_name = str(request.user.username)
        script_title = x.upload_ppt.name.split("/")[-1]
        request.session["slide_title"] = script_title
        print("pptuploadedfn2")
        prs = Presentation(x.upload_ppt)
        numPages = len(prs.slides)
        x.slide_count = numPages
        print(len(prs.slides), "pptuploadedfn3")
        x.save()
        MyURL = "/media/scripts/ppt/" + str(script_title)
        i = 1
        for slide in prs.slides:
            print("slide number %d" % i)
            i += 1
            etc_list = ["", " ", ",", " ,"]
            sentence = ""
            non_dial_src_lang = ""
            script_use = ""
            if slide.shapes[0].text is not None:
                sentence = slide.shapes[0].text
                sentence = re.sub(
                    """[!@#$%^&*()+=}{:;"'<>?/_-]""", "", sentence)
                if len(sentence) < 5:
                    continue
                non_dial_src_lang = language_detector(sentence)
                script_use = script_det(sentence)
                if non_dial_src_lang != "" and script_use != "":
                    print(i, "slidessssssssssssss")
                    print(
                        non_dial_src_lang, script_use, "languagesssssssssssssssssssssss"
                    )
                    break
            else:
                if slide.has_notes_slide:
                    text_frame = slide.notes_slide.notes_text_frame
                    if len(text_frame.text) > 0:
                        try:
                            if text_frame.text in etc_list:
                                continue
                                # print("text", text_frame.text)
                            sentence = text_frame.text
                            translator = Translator()
                            non_dial_src_lang = language_detector(sentence)
                            script_use = script_det(sentence)
                            if non_dial_src_lang != "" and script_use != "":
                                break
                        except:
                            non_dial_src_lang = ""
                            sentence = ""
                            script_use = ""
                        else:
                            break

                if sentence == "":

                    for shape in slide.shapes:
                        if not shape.has_text_frame:
                            continue
                        for paragraph in shape.text_frame.paragraphs:
                            for index, paragraph_run in enumerate(paragraph.runs):
                                try:
                                    if paragraph_run.text in etc_list:
                                        continue
                                    sentence = paragraph_run.text
                                    translator = Translator()
                                    non_dial_src_lang = language_detector(
                                        sentence)
                                    script_use = script_det(sentence)
                                    if non_dial_src_lang != "" and script_use != "":
                                        break
                                except:
                                    non_dial_src_lang = ""
                                    sentence = ""
                                    script_use = ""
                                else:
                                    break

        # slide = prs.slides[0]
        # heading = slide.shapes.title.text
        # translator = Translator()
        # non_dial_src_lang = translator.detect(heading)
        # print("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
        #       non_dial_src_lang.lang)
        # script_use = script_det(heading)
        # print("script used: ", script_use)
        # print("The Data of formInput is:", formInput)
        request.session["script_use"] = script_use
        context = {
            "id": user_id,
            "numPages": numPages,
            "ppt": x.upload_ppt,
            "option4": languages,
            "fileName": MyURL,
            "non_dial_src_lang": non_dial_src_lang,
            "non_dial_src_lang_full": languages.get(non_dial_src_lang),
            "author_name": author_name,
            "script_title": script_title,
            "Uppt": prs,
        }
        print("-----------------------------------------------")
        print(context)

        return render(request, "conversion/pptupload.html", context)
    return render(request, "conversion/pptupload.html")


# -> Actually Running Translation and Transliteration of PPT
def convertppt(request):
    if request.method == "POST":
        x = pptconversion.objects.get(ppt_string=request.session["pptstring"])
        source_language = request.POST.get("non_dial_src_lang")
        x.source_lang = languages[source_language]
        x.source_script = request.session["script_use"]
        x.target_lang = request.POST.get("nondial_dest_language")
        x.target_script = request.POST.get("dial_dest_script")
        print(request.POST.get("to_be_vetted_by_lpp"), "Akashhhh")
        if request.POST.get("to_be_vetted_by_lpp") == "on":
            x.lpp = True
        id = x.ppt_id
        if x.slide_count <= 3:
            x.amount = 0
            x.save()
            with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
                body = f.read()

            context_email = {
                "Date": date.today(),
                "Name": x.user_id.email,
                "emailcode": "",
                "heading1": "Thank you!",
                "heading2": " for using ppt conversion service "
                + " you will get notification whenever the conversation completes",
                "body": body,
            }
            # whomtosend, titleofmail, dateofemail, context\
            sendemail(
                x.user_id.email,
                "Thankyou for using service",
                date.today(),
                context_email,
                EMAIL_HOST_USER,
            ).start()
            print("Starting conversion of ppt")

            ppt_conversion(x.ppt_id, request).start()
            print("ending conversion of ppt")
            return render(request, "conversion/thanksppt.html")
        context = {}
        context["ppt_id"] = id
        print("ending conversion of ppt1")
        # payment calculation for presentation
        pdiscount = 1
        sdiscount = 1
        mdiscount = 1 - RUNNING_DISCOUNT_CONVERSION / 100

        if not privilegedUser1.objects.filter(
            user=request.user, is_active="yes"
        ).exists():
            messages.success(request, "Become privileged member")
            return redirect("payment")
        memberType = privilegedUser1.objects.get(
            user=request.user, is_active="yes"
        ).memberType
        print("ending conversion of ppt2")
        if memberType:
            if memberType == "normal":
                pdiscount = 1
                context["pdiscount"] = 0
            elif memberType == "yearly":
                pdiscount = 1 - YEARLY_MEMBER_ADDITIONAL / 100
                context["pdiscount"] = YEARLY_MEMBER_ADDITIONAL
            elif memberType == "Life Member":
                pdiscount = 1 - LIFE_MEMBER_ADDITIONAL / 100
                context["pdiscount"] = LIFE_MEMBER_ADDITIONAL
        print("ending conversion of ppt3")
        if User.objects.get(id=request.user.id).is_staff:
            sdiscount = 1 - EMPLOY_DISCOUNT / 100
        if request.POST.get("to_be_vetted_by_lpp") == "on":
            lpp_available = "yes"
            amt = x.slide_count * CONVERSION_PER_PAGE
            context["subtotal"] = round(amt, 2)

            lppamt = (x.slide_count * CONVERSION_PER_PAGE) + (
                x.slide_count * LPP_PER_PAGE
            )
            context["onlylppfee"] = round((x.slide_count * LPP_PER_PAGE), 2)
            amount_to_be_given_to_lpp = round(
                mdiscount * context["onlylppfee"] * pdiscount * sdiscount, 2
            )
            context["sublpptotal"] = round(lppamt, 2)
            context["amount"] = round(
                mdiscount * lppamt * pdiscount * sdiscount, 2)
            x.amount = context["amount"]
            request.session["pptamount"] = context["amount"]
            context["discount"] = lppamt - context["amount"]
            request.session["pptdiscount"] = lppamt - context["amount"]
            request.session["lppamount_after_discount"] = amount_to_be_given_to_lpp
            print("ending conversion of ppt4")
        else:
            print("ending conversion of ppt5")
            lpp_available = "no"
            amt = x.slide_count * CONVERSION_PER_PAGE
            context["subtotal"] = round(amt, 2)
            context["amount"] = round(
                mdiscount * amt * pdiscount * sdiscount, 2)
            context["discount"] = amt - context["amount"]
            x.amount = context["amount"]
            request.session["pptamount"] = context["amount"]
            request.session["pptdiscount"] = amt - context["amount"]
        print("ending conversion of ppt6")
        context["conversion_per_page"] = CONVERSION_PER_PAGE
        context["lpp_per_page"] = LPP_PER_PAGE
        context["running_discount_conversion"] = RUNNING_DISCOUNT_CONVERSION
        context["employ_discount"] = EMPLOY_DISCOUNT
        context["yearly_member_additional"] = YEARLY_MEMBER_ADDITIONAL
        context["life_member_additional"] = LIFE_MEMBER_ADDITIONAL
        context["restrict_to_five"] = "no"
        context["lpp_available"] = lpp_available.upper()
        context["numPages"] = x.slide_count
        # context["script_title"] = x.script_title
        context["ndial_src"] = x.source_lang
        context["ndial_dest"] = x.target_lang
        context["dial_dest_script"] = x.target_script
        context["dial_src_script"] = x.source_script
        context["script_title"] = request.session["slide_title"].split(".")[0]
        print("ending conversion of ppt7")
        x.save()
        print("ending conversion of ppt8")

        try:
            wall = Wallet.objects.get(user=request.user)
            context["balance"] = wall.balance
        except:
            context["balance"] = -1
        with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
            curr = json.load(c)
            try:
                rate = curr["rates"]["INR"]
                # c = CurrencyRates()
                # rate = c.get_rate("USD", str(currency.upper()))
            except Exception as e:
                print("checkout error", e)
                rate = 80
        context["rate"] = rate
        return render(request, "conversion/ppt_checkout.html", context)


# -> For Deleting your PPT
def delete_ppt(request, id):
    pptconversion.objects.get(ppt_id=id).delete()
    return HttpResponseRedirect("/conversion/view_conversion")


# -> Feedback on Conversion of PPT by User
def feedback_ppt(request):
    if request.method == "POST":
        x = pptconversion.objects.get(ppt_id=request.POST.get("pptid"))
        if (
            str(request.POST.get("error_text")) == " "
            or str(request.POST.get("error_text")) == ""
        ):
            x.error_faced_feedback = ""
        else:
            x.error_faced_feedback = str(request.POST.get("error_text"))
        if request.POST.get("rating") == " " or request.POST.get("rating") == "":
            x.translation_accuracy_rate = 0
        else:
            x.translation_accuracy_rate = int(request.POST.get("rating"))
        x.improvement_feedback = str(request.POST.get("improvement"))
        x.attention_feedback = str(request.POST.get("text"))
        try:
            x.exp_rate = int(request.POST.get("accurate"))
        except:
            pass
        try:
            x.content_accuracy_rate = int(request.POST.get("language"))
        except:
            pass
        x.save()
        with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
            body = f.read()

        context_email = {
            "Date": date.today(),
            "Name": x.user_id.email,
            "emailcode": "",
            "heading1": "Thank you!",
            "heading2": " your feedback is very important for us, thankyou for feedback ",
            "body": body,
        }
        # whomtosend, titleofmail, dateofemail, context\
        sendemail(
            x.user_id.email,
            "Feedback recieved",
            date.today(),
            context_email,
            EMAIL_HOST_USER,
        ).start()
        print("feedback of ppt mail")
        return redirect("view_conversion")