import re
from urllib.parse import parse_qs
from base64 import b64decode
from flask import Blueprint, request  # Import necessary functions
import xmltodict
from kbinxml import KBinXML
from lz77 import lz77_decompress
from misc import repair_base64, repair_base64IIDX
from variables.protocols import IIDX_Protocol, IIDX_XML, IIDX_RESULT, EAC_XML, EAC_RESULT, Respond, ddrgpHash, gitadoraHash, nostalgiaHash, sdvxHash, popnHash, infinitasHash, infinitasVersionHash
from variables.strings.preLaunch import checkVersion, LauncherData, ResourceInfo, getHash
from variables.strings.eacnet import eacGoodsList
from variables.strings.games.iidx import goodsList
from variables.strings.games.ddrgp import ddrGPGoods
from database import obtainGameHashs
bp = Blueprint(
    "needlessAuth", __name__, url_prefix="/needlessAuth"
)  # Create a Blueprint for this route section


@bp.route("/CheckGameVersion", methods=["POST"])
@bp.route("/CheckVersion", methods=["POST"])
@bp.route("/CheckLauncherVersion", methods=["POST"])
def CheckGameVersion():
    if request.method == "POST":
        # Access post data
        post_data = request.get_data().decode("UTF-8")
        variables = parse_qs(post_data)
        protocolVersion = variables["protocol_version"][0]
        if protocolVersion == IIDX_Protocol:
            pre_response = checkVersion.format(protocol=IIDX_XML,result=IIDX_RESULT).encode("utf-8")
        else:
            pre_response = checkVersion.format(protocol=EAC_XML,result=EAC_RESULT).encode("utf-8")
        response = KBinXML(pre_response)
        binary_data = response.to_binary()
        return Respond(binary_data, protocolVersion)

    return "Invalid request method", 400

@bp.route("/GetLauncherData", methods=["POST"])
@bp.route("/GetInformation", methods=["POST"])
def GetLauncherData():
    if request.method == "POST":
        post_data = request.get_data().decode("UTF-8")

        variables = parse_qs(post_data)
        protocolVersion = variables["protocol_version"][0]
        if protocolVersion == "P2D:2015091800":
            response = KBinXML(re.sub(r"eacnet","p2d",re.sub(r"response","result",LauncherData.decode())).encode())
        else:
            response = KBinXML(LauncherData)

        binary_data = response.to_binary()
        return Respond(binary_data, protocolVersion)

    return "Invalid request method", 400


@bp.route("/GetResourceInfo", methods=["POST"])
def GetResourceInfo():
    if request.method == "POST":
        # Access post data
        post_data = request.get_data().decode("UTF-8")

        variables = parse_qs(post_data)
        protocolVersion = variables["protocol_version"][0]

        kbinxml_data = ""
        preResponse = b""
        # Example: Decoding and processing data
        try:
            decoded_data = b64decode(repair_base64(variables["request"][0]))
            decompressed_data = lz77_decompress(decoded_data)
            kbinxml_data = KBinXML(decompressed_data).to_text()
            eacnetRequest = xmltodict.parse(kbinxml_data)
            version = eacnetRequest["eacnet"]["info"]["game_id"]["#text"]
            if version == "ddr":
                preResponse = ResourceInfo.format(
                    ResourceURL="https://d2el0dli9l0x2p.cloudfront.net/list/resource_info_pro_2024102200_08f254.xml",
                    ResourceHash="08f254387c6f7837f82d4e0705e78263f3e6cc6c3f2f58c801abf195528f3749",
                ).encode()
            elif version == "gitadora":
                preResponse = ResourceInfo.format(
                    ResourceURL="https://d1omkh45tn6edw.cloudfront.net/data/list/resource_info_2024091800pro_aUu49b6f.xml",
                    ResourceHash="1974839bf421c51c5c9518ad005306afe93d00880d5c4566b06c93f13ad5dc4b",
                ).encode()
            elif version == "sdvx":
                preResponse = ResourceInfo.format(
                    ResourceURL="https://dks1q2aivwkd6.cloudfront.net/vi/downloads/resource_info/resource_info_pro_2024102300.xml",
                    ResourceHash="ab4f36484b52dcd551a585a68f355582adc6157706539302b43727bbc30c09a0",
                ).encode()
            elif version == "nostalgia":
                preResponse = ResourceInfo.format(
                    ResourceURL="https://d26kzmeiv4899f.cloudfront.net/data/list/resource_info_2023112800pro.xml",
                    ResourceHash="5256582a366d2028da7488f1c1fde8ab04f50e727eb82af1631a6403faccf1c0",
                ).encode()
            elif version == "popn-music":
                preResponse = ResourceInfo.format(
                    ResourceURL="https://d1twxdn5j8sbm3.cloudfront.net/ResourceInfo/U39JAA2024103000_resource_info_pro.xml",
                    ResourceHash="a606483baa8b7ff66740ff27474113b01965add8eadc41fa5ec78fc83dca6246",
                ).encode()
            # Process kbinxml_data
        except Exception as e:
            print(f"Error processing data: {e}")

        response = KBinXML(preResponse)
        binary_data = response.to_binary()
        return Respond(binary_data, protocolVersion)

    return "Invalid request method", 400


@bp.route("/GetHash", methods=["POST"])
@bp.route("/GetFile", methods=["POST"])
def GetHash():
    if request.method == "POST":
        # Access post data
        post_data = request.get_data().decode("UTF-8")

        variables = parse_qs(post_data)
        protocolVersion = variables["protocol_version"][0]

        kbinxml_data = ""
        preResponse = b""
        # Example: Decoding and processing data
        print(repair_base64(variables["request"][0]))
        try:
            if variables["protocol_version"][0] == "P2D:2015091800":
                decoded_data = b64decode(repair_base64IIDX(variables["request"][0]))
            else:
                decoded_data = b64decode(repair_base64(variables["request"][0]))
            decompressed_data = lz77_decompress(decoded_data)
            kbinxml_data = KBinXML(decompressed_data).to_text()
            eacnetRequest = xmltodict.parse(kbinxml_data)
            
            if protocolVersion == "P2D:2015091800":
                version = eacnetRequest["p2d"]["params"].get("name", {}).get("#text", {})
                clientversion = variables["client_version"][0]
                print(clientversion)
                print(type(clientversion))
                print(type(version))
                if type(version) == dict:
                    if clientversion == "P2D:J:B:A:2024121800":
                        gameHashes = obtainGameHashs("iidx-v2")
                        preResponse = getHash.format(hash=gameHashes.known_hash,protocol=IIDX_XML,result=IIDX_RESULT)
                    elif clientversion == "P2D:J:A:A:2020122300":
                        gameHashes = obtainGameHashs("iidx-v2")
                        preResponse = getHash.format(hash=gameHashes.known_hash,protocol=IIDX_XML,result=IIDX_RESULT)
                    else:
                        gameHashes = obtainGameHashs("iidx-v1")
                        preResponse = getHash.format(hash=gameHashes.known_hash,protocol=IIDX_XML,result=IIDX_RESULT)

                else:
                    gameHashes = obtainGameHashs("iidx-v3")
                    preResponse = getHash.format(hash=gameHashes.known_hash or infinitasVersionHash,protocol=IIDX_XML,result=IIDX_RESULT)
            else:
                version = eacnetRequest["eacnet"]["info"]["game_id"]["#text"]
                print(version)
                gameHashes = obtainGameHashs(version)
                preResponse = getHash.format(hash=gameHashes.known_hash,protocol=EAC_XML,result=EAC_RESULT)
            # Process kbinxml_data
        except Exception as e:
            print(f"Error processing data: {e}")
        response = KBinXML(preResponse.encode())
        binary_data = response.to_binary()
        return Respond(binary_data, protocolVersion)

    return "Invalid request method", 400

@bp.route("/GetGoodsList", methods=["POST"])
def GetGoodsList():
    if request.method == "POST":
        # Access post data
        post_data = request.get_data().decode("UTF-8")

        variables = parse_qs(post_data)

        # Access headers
        binary_data = b""
        preResponse = ""
        if isinstance(binary_data, str):
            binary_data = binary_data.encode("utf-8")
        if variables["protocol_version"][0] == "P2D:2015091800":
            response = KBinXML(goodsList)
            binary_data = response.to_binary()
            return Respond(binary_data,variables["protocol_version"][0])
        else:
            try:
                decoded_data = b64decode(repair_base64(variables["request"][0]))
                decompressed_data = lz77_decompress(decoded_data)
                kbinxml_data = KBinXML(decompressed_data).to_text()
                eacnetRequest = xmltodict.parse(kbinxml_data)
                version = eacnetRequest["eacnet"]["info"]["game_id"]["#text"]
                match version:
                    case "ddr":
                        preResponse = eacGoodsList.format(goods_num="3",goods=ddrGPGoods)
                    case "popn-music":
                        preResponse = eacGoodsList.format(goods_num="19",goods="")
                    case _:
                        preResponse = eacGoodsList.format(goods_num="0",goods="")
                # Process kbinxml_data
            except Exception as e:
                print(f"Error processing data: {e}")
            response = KBinXML(preResponse.encode())
            binary_data = response.to_binary()

        return Respond(binary_data,variables["protocol_version"][0])

    return "Invalid request method", 400