from flask import Flask, render_template, jsonify, request, send_file
import requests
import http.client
import json
import time
import re
from strgen import StringGenerator as SG

app = Flask(__name__)


def encrypt(text):
    s = int(re.search(r'\d+', text).group()[0])
    result = ""
    for i in range(len(text)):
        char = text[i]
        if(not char.isnumeric() and char != "-"):
            if (char.isupper()):
                result += chr((ord(char) + s - 65) % 26 + 65)
            else:
                result += chr((ord(char) + s - 97) % 26 + 97)
        else:
            result += char
    return result


def dencrypt(text):
    s = int(re.search(r'\d+', text).group()[0])
    result = ""
    for i in range(len(text)):
        char = text[i]
        if(not char.isnumeric() and char != "-"):
            if (char.isupper()):
                result += chr((ord(char) - s - 65) % 26 + 65)
            else:
                result += chr((ord(char) - s - 97) % 26 + 97)
        else:
            result += char
    return result


def NewAccount():
    # Genrate CSRF
    conn = http.client.HTTPSConnection("lexica.art")
    payload = ''
    conn.request("GET", "/api/auth/csrf", payload)
    response = conn.getresponse()
    csrf = json.loads(response.read().decode("utf-8"))["csrfToken"]
    print("CSRF :", csrf)
    cookies = response.getheader("Set-Cookie")

    # Genrate Temp Mail
    tempEmail = json.loads(requests.get(
        "https://www.1secmail.com/api/v1/?action=genRandomMailbox&count=1").text)[0]
    login = tempEmail.split("@")[0]
    domain = tempEmail.split("@")[1]
    print("Tempmail :", tempEmail)

    # Send Mail From Lexica
    csrfTokenCookie = str(cookies).split(
        "__Host-next-auth.csrf-token=")[1].split(";")[0]
    cookiesText = '__Host-next-auth.csrf-token='+csrfTokenCookie + \
        '; __Secure-next-auth.callback-url=https%3A%2F%2Flexica.art%2F'
    payload = 'email='+tempEmail + \
        '&redirect=false&callbackUrl=https%3A%2F%2Flexica.art%2F&csrfToken='+csrf+'&json=true'
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Cookie': cookiesText
    }
    conn.request("POST", "/api/auth/signin/email?=null", payload, headers)
    response = conn.getresponse()
    if ("provider=email&type=email" in response.read().decode("utf-8")):
        print("Email Sent :", True)

    # Recieve Mail from Lexica
    while True:
        mailData = json.loads(requests.get(
            "https://www.1secmail.com/api/v1/?action=getMessages&login="+login+"&domain="+domain).text)
        if(len(mailData) > 0):
            mailId = mailData[0]["id"]
            break
        time.sleep(0.5)

    mailBody = json.loads(requests.get(
        "https://www.1secmail.com/api/v1/?action=readMessage&login="+login+"&domain="+domain+"&id="+str(mailId)).text)["textBody"]
    sessionLink = mailBody.split('<a href=\"')[1].split('\">')[0].strip()
    print(sessionLink)

    # Activate A New Account
    payload = ''
    headers = {
        'Cookie': cookiesText
    }
    conn.request("GET", "/"+sessionLink.split("lexica.art/")
                 [1], payload, headers)
    res = conn.getresponse()
    data = res.read()
    cookies = res.getheader("Set-Cookie")
    print(data.decode("utf-8"))
    print(cookies)
    sessionTokenCookie = str(cookies).split(".session-token=")[1].split(";")[0]
    return csrfTokenCookie, sessionTokenCookie


f = open("accountInfo.json")
loginData = json.load(f)
if loginData != {}:
    csrfTokenCookie = loginData["csrfTokenCookie"]
    sessionTokenCookie = loginData["sessionTokenCookie"]
else:
    csrfTokenCookie, sessionTokenCookie = NewAccount()
    json_object = json.dumps({"csrfTokenCookie": csrfTokenCookie,
                             "sessionTokenCookie": sessionTokenCookie}, indent=4)
    with open("accountInfo.json", "w") as outfile:
        outfile.write(json_object)

f = open("genAccountInfo.json")
loginData = json.load(f)
if loginData != {}:
    csrfTokenCookieGEN = loginData["csrfTokenCookieGEN"]
    sessionTokenCookieGEN = loginData["sessionTokenCookieGEN"]
    visitorId = loginData["visitorId"]
else:
    csrfTokenCookieGEN, sessionTokenCookieGEN = NewAccount()
    visitorId = SG("[\l\d]{20}").render_list(1, unique=True)[0]
    json_object = json.dumps({"csrfTokenCookieGEN": csrfTokenCookie,
                             "sessionTokenCookieGEN": sessionTokenCookie, "visitorId": visitorId}, indent=4)
    with open("genAccountInfo.json", "w") as outfile:
        outfile.write(json_object)


def infiniteScroll(cursor, query, searchMode, model):
    global csrfTokenCookie
    #conn = http.client.HTTPSConnection("lexica.art")
    print(query)
    try:
        cursor = int(cursor)
    except:
        cursor = 0
    payload = {
        "text": query,
        "searchMode": searchMode,
        "source": "search",
        "cursor": int(cursor),
        "model": model
    }
    headers = {
        'Content-Type': 'application/json',
        'Cookie': '__Host-next-auth.csrf-token='+csrfTokenCookie+'; __Secure-next-auth.callback-url=https%3A%2F%2Flexica.art'
    }
    # conn.request("POST", "/api/infinite-prompts", payload, headers)
    # res = conn.getresponse()
    # data = res.read()
    proxy = "http://b6cc19fa02905563b3f00d96357d94ac63247c60:@proxy.zenrows.com:8001"
    proxies = {"http": proxy, "https": proxy}
    response = requests.post("https://lexica.art/api/infinite-prompts",headers=headers, json=payload,proxies=proxies, verify=False)
    #return json.loads(data.decode("utf-8"))
    return json.loads(response.text)


@app.route('/infinite-prompts', methods=["POST", "GET"])
def homeImageLoader():
    if request.method == 'POST':
        try:
            cursor = request.form['cursor']
        except:
            cursor = 0
        try:
            query = request.form['query']
        except:
            query = ""
        searchMode = request.form['searchMode']
        model = request.form['model']
        if(model == "picxai-diffuser"):
            model = "lexica-aperture-v2"
        if(searchMode == "prompts"):
            model = "sd-1.5"
        data = infiniteScroll(cursor, query, searchMode, model)
        return data


@app.route('/prompt/<id>', methods=["GET"])
def promptDetail(id):
    f = open('picxai.json', "r", encoding="utf-8")
    data = json.loads(f.read())
    flag = 0
    for i in data["data"]:
        for j in i["prompts"]:
            if j["id"] == id:
                datafinal = j
                flag = 1
                break
    if flag == 0:
        f = open('sd1-5.json', "r", encoding="utf-8")
        data = json.loads(f.read())
        for i in data["data"]:
            for j in i["prompts"]:
                if j["id"] == id:
                    datafinal = j
                    break
    return render_template("prompt.html", datafinal=datafinal)


@app.route('/diffuser', methods=["POST", "GET"])
def diffuser():
    global csrfTokenCookieGEN, sessionTokenCookieGEN, visitorId
    if request.method == 'POST':
        try:
            prompt = request.form['prompt']
            print(prompt)
            negativePrompt = request.form['negativePrompt']
            guidanceScale = request.form['guidanceScale']
            enableHiresFix = str(request.form['enableHiresFix'])
            width = request.form['width']
            height = request.form['height']
            payload = json.dumps({
                "prompt": prompt,
                "negativePrompt": negativePrompt,
                "guidanceScale": int(guidanceScale),
                "width": int(width),
                "height": int(height),
                "enableHiresFix": enableHiresFix,
                "model": "lexica-aperture-v2",
                "numImagesGenerated": 0,
                "id": visitorId
            })
            headers = {
                'authority': 'z.lexica.art',
                'accept': 'application/json, text/plain, */*',
                'content-type': 'application/json',
                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36',
                'Cookie': '__Secure-next-auth.session-token='+sessionTokenCookieGEN+'; __Host-next-auth.csrf-token='+csrfTokenCookieGEN+';'
            }
            conn = http.client.HTTPSConnection("z.lexica.art")
            conn.request("POST", "/api/generator", payload, headers)
            res = conn.getresponse()
            data = res.read()
            if "needsMembership" in data.decode("utf-8"):
                csrfTokenCookieGEN, sessionTokenCookieGEN = NewAccount()
                visitorId = SG("[\l\d]{20}").render_list(1, unique=True)[0]
                json_object = json.dumps({"csrfTokenCookieGEN": csrfTokenCookieGEN,
                                         "sessionTokenCookieGEN": sessionTokenCookieGEN, "visitorId": visitorId}, indent=4)
                with open("genAccountInfo.json", "w") as outfile:
                    outfile.write(json_object)
                data = {"error": "Please try Again"}
                return jsonify(data)
            try:
                images = json.loads(data.decode("utf-8"))["images"]
                with open("images.txt", "a", encoding="utf-8") as file1:
                    for img in images:
                        file1.write(str(img["url"]+"\n"))
                    file1.close()
            except:
                pass
            return jsonify(data.decode("utf-8"))
        except Exception as e:
            return jsonify({"error": str(e)})
    else:
        return render_template("generate.html")


@app.route('/image/<size>/<id>', methods=["GET"])
def imageAPI(size, id):
    print(size, id)
    return send_file(filename, mimetype='image/jpg')


@app.route('/', methods=["GET"])
def home():
    return render_template("index.html")


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=7860)