import logging
from flask import Flask, request, jsonify
from flask_cors import CORS
import traceback
import asyncio

from database.inventory.inventory_data import SubAffix
from game_server.game.player.player_manager import PlayerManager
from game_server.net.session import PlayerSession
from game_server.srtools.models.srtools_data import SRToolDataRsp,SRToolDataReq,SRToolData
from database.account.account_data import find_account_by_name
from utils.logger import Info
from game_server.srtools.gateway import get_gateway_instance
flask_app = Flask(__name__)
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR)
CORS(flask_app, resources={r"/*": {"origins": "https://srtools.pages.dev"}})


async def ClearInventory(conn: PlayerSession):
    # un equip all lightcones and relic after that remove it
    for _, items in list(conn.player.inventory_manager.items()):
        if items.equip_avatar != 0 and items.main_type in (1, 2):
            await conn.player.unequip_items(items.equip_avatar)
            if items.main_type == 1:
                await conn.notify(items.LightconeSyncProto())
            if items.main_type == 2:
                await conn.notify(items.RelicSyncProto())
            await conn.player.remove_items(0, items.unique_id)

async def AddAllData(player: PlayerManager, data: SRToolData):
    for key, avatar_data in data.avatars.items():
        avatar = player.avatar_manager.get(avatar_data.avatar_id)
        if avatar_data.avatar_id >= 8000:continue
        if not avatar:
            avatar = player.add_avatar(avatar_data.avatar_id)
            if avatar:
                player.avatar_manager[avatar_data.avatar_id] = avatar

        avatar.level = avatar_data.level
        avatar.promotion = avatar_data.promotion
        avatar.rank = avatar_data.data.rank if avatar_data.data else 0
        avatar.skills = avatar_data.data.skills

    for lightcone in data.lightcones:
        if lightcone.equip_avatar > 8000:continue
        lightcone_data = player.add_lightcone(
            lightcone.item_id,
            lightcone.rank
        )
        if lightcone_data:
            if lightcone.equip_avatar > 0:
                player.avatar_manager[lightcone.equip_avatar].lightcone_id = lightcone_data.unique_id
                lightcone_data.equip_avatar = lightcone.equip_avatar
            player.inventory_manager[lightcone_data.unique_id] = lightcone_data

    for relic in data.relics:
        if relic.equip_avatar > 8000:continue
        relic_data = player.add_relic(
            relic_id=relic.relic_id,
            main_affix=relic.main_affix_id,
            sub_affix=[
                SubAffix(
                    id=affix.sub_affix_id,
                    count=affix.count,
                    step=affix.step
                )
                for affix in relic.sub_affixes
            ]
        )
        if relic_data:
            if relic.equip_avatar > 0:
                player.avatar_manager[relic.equip_avatar].relic_ids[str(relic_data.sub_type)] = relic_data.unique_id
                relic_data.equip_avatar = relic.equip_avatar
            player.inventory_manager[relic_data.unique_id] = relic_data


@flask_app.route("/srtools", methods=["POST"])
async def srtools_handler():
    body = request.get_json()
    try:
        req = SRToolDataReq(**body)
    except Exception:
        return jsonify({"message": "Invalid input", "status": 400}), 400

    rsp = SRToolDataRsp(message="OK", status=200)

    account = find_account_by_name(req.username)
    if not account:
        rsp.message = "Invalid account"
        rsp.status = 400
        return jsonify(rsp.model_dump()), 401

    if req.data is None:
        return jsonify(rsp.model_dump()), 200

    gateway = get_gateway_instance()
    conn : PlayerSession = gateway.get_active_connection(account.id)
    if not conn:
        rsp.message = "Player Not Online"
        rsp.status = 401
        return jsonify(rsp.model_dump()), 401

    try:
        await ClearInventory(conn)
        await AddAllData(conn.player,req.data)
        conn.pending_notify(conn.player.SrToolItemsSync())
        conn.pending_notify(conn.player.SrToolAvatarSync())
    except:
        rsp.message = "Internal Server Error"
        rsp.status = 500
        print(traceback.print_exc())
        return jsonify(rsp.model_dump()), 500
    return jsonify(rsp.model_dump()), 200

def run_flask(host, port):
    Info(f"SRTools Server Starting on {host}:{port}")
    flask_app.run(host=host, port=port)