from urllib.parse import parse_qs
from base64 import b64decode
from flask import Blueprint, request  # Import necessary functions
from kbinxml import KBinXML
from routes.eacnet.relays import gitadora
from variables.protocols import IIDX_XML, IIDX_RESULT, EAC_XML, EAC_RESULT, Respond, EAC_PROTOCOL_1, EAC_PROTOCOL_2
from misc import repair_base64
from lz77 import lz77_decompress
import xmltodict
from variables.strings.preLaunch import GenericOK
from variables.strings.common import heartbeat, genericError, standardEACNet, ReserveItemEAC, consumeItemEAC
from variables.strings.eacnet import subscriptionStatus, konasuteUserID, eacItemList
from routes.eacnet.relays import ddrgp, gitadora, nostalgia#, popn, sdvx
from database import (
    add_user_eacnet,
    getEacnetProfilebyToken,
    update_save_data_consumablesEAC
)

bp = Blueprint(
    "needAuth", __name__, url_prefix="/eacnet/needAuth"
)  # Create a Blueprint for this route section

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

        variables = parse_qs(post_data)

        if variables["protocol_version"][0] != "2020090800":
            return "Version Not Supported.", 400

        kbinxml_data = ""
        token = ""
        preResponse = b""
        profile = None
        # Example: Decoding and processing data
        try:
            decoded_data = b64decode(repair_base64(variables["request"][0]))
            print(type(decoded_data))
            decompressed_data = lz77_decompress(decoded_data)
            kbinxml_data = KBinXML(decompressed_data).to_text()
            eacnetRequest = xmltodict.parse(kbinxml_data)
            print(eacnetRequest["eacnet"]["info"])
            token = eacnetRequest["eacnet"]["info"]["token"]["#text"]
            # Process kbinxml_data

            profile = getEacnetProfilebyToken(token)

            if profile is None:
                profile = add_user_eacnet(token)

            preResponse = konasuteUserID.format(ref_id=profile.refid,sns_id=profile.snsid).encode("utf-8")
        except Exception as e:
            print(f"Error processing data: {e}")

        response = KBinXML(preResponse)

        binary_data = response.to_binary()
        return Respond(binary_data,variables["protocol_version"][0])

    return "Invalid request method", 400

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

        variables = parse_qs(post_data)

        if variables["protocol_version"][0] != "2020090800":
            return "Version Not Supported.", 400

        kbinxml_data = ""
        subscriptionName = ""
        # Example: Decoding and processing data
        try:

            decoded_data = b64decode(repair_base64(variables["request"][0]))
            print(bytes.hex(decoded_data))
            decompressed_data = lz77_decompress(decoded_data)
            kbinxml_data = KBinXML(decompressed_data).to_text()
            print(kbinxml_data)
            eacnetRequest = xmltodict.parse(kbinxml_data)
            print(eacnetRequest["eacnet"]["info"])
            version = eacnetRequest["eacnet"]["info"]["game_id"]["#text"]
            if version == "ddr":
                subscriptionName = "eac_ddr_basic"
            elif version == "gitadora":
                subscriptionName = "eacgitadora_basic"
            elif version == "sdvx":
                subscriptionName = "eac_sdvx_basic"
            elif version == "nostalgia":
                subscriptionName = "eac_nostalgia_basic"
            elif version == "popn-music":
                subscriptionName = "EAC_POPNLIVELY"

            # Process kbinxml_data
        except Exception as e:
            print(f"Error processing data: {e}")

        response = KBinXML(
            subscriptionStatus.format(subscriptionName=subscriptionName).encode("utf-8")
        )
        binary_data = response.to_binary()
        return Respond(binary_data,variables["protocol_version"][0])

    return "Invalid request method", 400


@bp.route("/GetItemList", methods=["POST"])
def GetItemList():
    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 = b""

        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"]
            token = eacnetRequest["eacnet"]["info"]["token"]["#text"]
            profile = getEacnetProfilebyToken(token)
            match version:
                case "ddr":
                    print(eacItemList.format(items_num="1",tickets=profile.ddrTicket,item_id="DDR_TICKET"))
                    preResponse = eacItemList.format(items_num="1",tickets=profile.ddrTicket,item_id="DDR_TICKET").encode()
                case "popn-music":
                    preResponse = eacItemList.format(items_num="1",tickets=profile.livelyTicket,item_id="LIVELY_TICKET").encode()
                case _:
                    preResponse = eacItemList.format(items_num="0",tickets="0",item_id="aa").encode()
            # Process kbinxml_data
        except Exception as e:
            print(f"Error processing data: {e}")
        response = KBinXML(preResponse)
        binary_data = response.to_binary()
        if isinstance(binary_data, str):
            binary_data = binary_data.encode("utf-8")

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

    return "Invalid request method", 400


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

        variables = parse_qs(post_data)
        print(variables)
        if variables["protocol_version"][0] != "2020090800":
            return "Version Not Supported.", 400

        kbinxml_data = ""
        handler = b"<error></error>"
        # 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"].get("#text", {})
            module = eacnetRequest["eacnet"]["request"]["module"].get("#text", {})
            method = eacnetRequest["eacnet"]["request"]["method"].get("#text", {})
            playerToken = eacnetRequest["eacnet"]["info"]["token"].get("#text", {})
            data = eacnetRequest["eacnet"]["request"].get("data", {})
            if version == "ddr":
                handler = ddrgp.DDRGPRelay(module, method, data, playerToken)
            elif version == "gitadora":
                handler = gitadora.gitadoraRelay(module, method, data, playerToken)
            #elif version == "sdvx":
            #    handler = sdvx.sdvxRelay(module, method, data, playerToken)
            elif version == "nostalgia":
                handler = nostalgia.nostalgiaRelay(module, method, data, playerToken)
            #elif version == "popn-music":
            #    handler = popn.popnRelay(module, method, data, playerToken)

            # Process kbinxml_data
        except Exception as e:
            print(f"Error processing data: {e}")
        response = KBinXML(handler)
        binary_data = response.to_binary()
        return Respond(binary_data,variables["protocol_version"][0])

    return "Invalid request method", 400


@bp.route("/ReserveConsumeItem", methods=["POST"])
def ReserveConsumeItem():
    if request.method == "POST":
        # Access post data
        post_data = request.get_data().decode("UTF-8")
        variables = parse_qs(post_data)
        profile = None
        transaction_success = False
        itemTemplate = ""
        token = None
        version = None

        if variables.get("protocol_version", [None])[0] != "2020090800":
            return "Version Not Supported.", 400

        try:
            # Decode and decompress request data
            decoded_data = b64decode(repair_base64(variables["request"][0]))
            decompressed_data = lz77_decompress(decoded_data)
            kbinxml_data = KBinXML(decompressed_data).to_text()
            pdata = xmltodict.parse(kbinxml_data)

            # Extract token and version
            token = pdata["eacnet"]["info"]["token"]["#text"]
            version = pdata["eacnet"]["info"]["game_id"]["#text"]
            profile = getEacnetProfilebyToken(token)
            # Extract goods_id, item_id, and consume_num
            goods_id = pdata["eacnet"]["request"]["data"]["goods_id"]["#text"]

            if profile is None:
                response = KBinXML(genericError.format(protocol=EAC_XML,result=EAC_RESULT))
                binary_data = response.to_binary()
                if isinstance(binary_data, str):
                    binary_data = binary_data.encode("utf-8")
                return Respond(binary_data,variables["protocol_version"][0])
            else:
                transaction_success = update_save_data_consumablesEAC(token, version, goods_id)
                profile = getEacnetProfilebyToken(token)
                ddrTicket = profile.ddrTicket
                livelyTicket = profile.livelyTicket
                match version:
                    case "ddr":
                        itemTemplate = f'<not_free_count __type="s32">{ddrTicket}</not_free_count>\n        <free_count __type="s32">0</free_count>\n'
                    case "popn-music":
                        itemTemplate = f'<not_free_count __type="s32">{livelyTicket}</not_free_count>\n        <free_count __type="s32">0</free_count>\n'

        except Exception as e:
            print(f"Error processing data: {e}")
            response = KBinXML(genericError.format(protocol=EAC_XML,result=EAC_RESULT))
            binary_data = response.to_binary()
            if isinstance(binary_data, str):
                binary_data = binary_data.encode("utf-8")
            
            return Respond(binary_data,variables["protocol_version"][0])

        # Prepare the response based on transaction success
        if transaction_success == True:
            print("Sending True")
            response = KBinXML(standardEACNet.format(
                        response=ReserveItemEAC,
                        status=0,
                        error=0
                ).encode()
            )
        else:
            response = KBinXML()

        binary_data = response.to_binary()
        return Respond(binary_data,variables["protocol_version"][0])

    return "Invalid request method", 400

@bp.route("/ConsumeItem", methods=["POST"])
def consumeItem():
    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 = b""

        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"]
            token = eacnetRequest["eacnet"]["info"]["token"]["#text"]
            profile = getEacnetProfilebyToken(token)
            match version:
                case "ddr":
                    preResponse = standardEACNet.format(
                        response=consumeItemEAC.format(
                            tickets=profile.ddrTicket,
                            item_id="DDR_TICKET"),
                        status=0,
                        error=0
                ).encode()
                case "popn-music":
                    preResponse = standardEACNet.format(
                        response=consumeItemEAC.format(
                            tickets=profile.livelyTicket,
                            item_id="LIVELY_TICKET"),
                        status=0,
                        error=0
                ).encode()
                case _:
                    preResponse = eacItemList.format(items_num="0",tickets="").encode()
            # Process kbinxml_data
        except Exception as e:
            print(f"Error processing data: {e}")
        response = KBinXML(preResponse)
        binary_data = response.to_binary()
        if isinstance(binary_data, str):
            binary_data = binary_data.encode("utf-8")

        if variables["protocol_version"][0] == "2017012700":
            return Respond(binary_data,variables["protocol_version"][0])

        elif variables["protocol_version"][0] == "2020090800":
            return Respond(binary_data,variables["protocol_version"][0])

    return "Invalid request method", 400