bemaniutils/bemani/backend/reflec/limelight.py

from typing import Optional, Dict, Any, Tuple
from typing_extensions import Final

from bemani.backend.reflec.base import ReflecBeatBase
from bemani.backend.reflec.reflecbeat import ReflecBeat

from bemani.common import Profile, VersionConstants, ID, Time
from bemani.data import UserID
from bemani.protocol import Node


class ReflecBeatLimelight(ReflecBeatBase):
    name: str = "REFLEC BEAT limelight"
    version: int = VersionConstants.REFLEC_BEAT_LIMELIGHT

    # Clear types according to the game
    GAME_CLEAR_TYPE_NO_PLAY: Final[int] = 0
    GAME_CLEAR_TYPE_FAILED: Final[int] = 2
    GAME_CLEAR_TYPE_CLEARED: Final[int] = 3
    GAME_CLEAR_TYPE_FULL_COMBO: Final[int] = 4

    # Reflec Beat Limelight requires non-expired profiles to do conversions properly
    supports_expired_profiles: bool = False

    def previous_version(self) -> Optional[ReflecBeatBase]:
        return ReflecBeat(self.data, self.config, self.model)

    @classmethod
    def get_settings(cls) -> Dict[str, Any]:
        """
        Return all of our front-end modifiably settings.
        """
        return {
            "bools": [
                {
                    "name": "Force Song Unlock",
                    "tip": "Force unlock all songs.",
                    "category": "game_config",
                    "setting": "force_unlock_songs",
                },
            ],
            "ints": [],
        }

    def __db_to_game_clear_type(self, db_clear_type: int, db_combo_type: int) -> int:
        if db_clear_type == self.CLEAR_TYPE_NO_PLAY:
            return self.GAME_CLEAR_TYPE_NO_PLAY
        if db_clear_type == self.CLEAR_TYPE_FAILED:
            return self.GAME_CLEAR_TYPE_FAILED
        if db_clear_type in [
            self.CLEAR_TYPE_CLEARED,
            self.CLEAR_TYPE_HARD_CLEARED,
            self.CLEAR_TYPE_S_HARD_CLEARED,
        ]:
            if db_combo_type in [
                self.COMBO_TYPE_NONE,
                self.COMBO_TYPE_ALMOST_COMBO,
            ]:
                return self.GAME_CLEAR_TYPE_CLEARED
            if db_combo_type in [
                self.COMBO_TYPE_FULL_COMBO,
                self.COMBO_TYPE_FULL_COMBO_ALL_JUST,
            ]:
                return self.GAME_CLEAR_TYPE_FULL_COMBO

            raise Exception(f"Invalid db_combo_type {db_combo_type}")
        raise Exception(f"Invalid db_clear_type {db_clear_type}")

    def __game_to_db_clear_type(self, game_clear_type: int) -> Tuple[int, int]:
        if game_clear_type == self.GAME_CLEAR_TYPE_NO_PLAY:
            return (self.CLEAR_TYPE_NO_PLAY, self.COMBO_TYPE_NONE)
        if game_clear_type == self.GAME_CLEAR_TYPE_FAILED:
            return (self.CLEAR_TYPE_FAILED, self.COMBO_TYPE_NONE)
        if game_clear_type == self.GAME_CLEAR_TYPE_CLEARED:
            return (self.CLEAR_TYPE_CLEARED, self.COMBO_TYPE_NONE)
        if game_clear_type == self.GAME_CLEAR_TYPE_FULL_COMBO:
            return (self.CLEAR_TYPE_CLEARED, self.COMBO_TYPE_FULL_COMBO)

        raise Exception(f"Invalid game_clear_type {game_clear_type}")

    def handle_log_exception_request(self, request: Node) -> Node:
        return Node.void("log")

    def handle_log_pcb_status_request(self, request: Node) -> Node:
        return Node.void("log")

    def handle_log_opsetting_request(self, request: Node) -> Node:
        return Node.void("log")

    def handle_log_play_request(self, request: Node) -> Node:
        return Node.void("log")

    def handle_pcbinfo_get_request(self, request: Node) -> Node:
        shop_id = ID.parse_machine_id(request.child_value("lid"))
        machine = self.get_machine_by_id(shop_id)
        if machine is not None:
            machine_name = machine.name
            close = machine.data.get_bool("close")
            hour = machine.data.get_int("hour")
            minute = machine.data.get_int("minute")
            pref = machine.data.get_int("pref", self.get_machine_region())
        else:
            machine_name = ""
            close = False
            hour = 0
            minute = 0
            pref = self.get_machine_region()

        root = Node.void("pcbinfo")
        info = Node.void("info")
        root.add_child(info)

        info.add_child(Node.string("name", machine_name))
        info.add_child(Node.s16("pref", pref))
        info.add_child(Node.bool("close", close))
        info.add_child(Node.u8("hour", hour))
        info.add_child(Node.u8("min", minute))

        return root

    def handle_pcbinfo_set_request(self, request: Node) -> Node:
        self.update_machine_name(request.child_value("info/name"))
        self.update_machine_data(
            {
                "close": request.child_value("info/close"),
                "hour": request.child_value("info/hour"),
                "minute": request.child_value("info/min"),
                "pref": request.child_value("info/pref"),
            }
        )
        return Node.void("pcbinfo")

    def __add_event_info(self, request: Node) -> None:
        events: Dict[int, int] = {}

        for _eventid, _phase in events.items():
            data = Node.void("data")
            request.add_child(data)
            data.add_child(Node.s32("type", -1))
            data.add_child(Node.s32("value", -1))

    def handle_sysinfo_get_request(self, request: Node) -> Node:
        root = Node.void("sysinfo")
        trd = Node.void("trd")
        root.add_child(trd)

        # Add event info
        self.__add_event_info(trd)

        return root

    def handle_ranking_read_request(self, request: Node) -> Node:
        root = Node.void("ranking")

        licenses = Node.void("lic_10")
        root.add_child(licenses)
        originals = Node.void("org_10")
        root.add_child(originals)

        licenses.add_child(Node.time("time", Time.now()))
        originals.add_child(Node.time("time", Time.now()))

        hitchart = self.data.local.music.get_hit_chart(self.game, self.version, 10)
        rank = 1
        for mid, _plays in hitchart:
            record = Node.void("record")
            originals.add_child(record)
            record.add_child(Node.s16("id", mid))
            record.add_child(Node.s16("rank", rank))
            rank = rank + 1

        return root

    def handle_event_r_get_all_request(self, request: Node) -> Node:
        limit = request.child_value("limit")

        comments = [
            achievement
            for achievement in self.data.local.user.get_all_time_based_achievements(
                self.game, self.version
            )
            if achievement[1].type == "puzzle_comment"
        ]
        comments.sort(key=lambda x: x[1].timestamp, reverse=True)
        statuses = self.data.local.lobby.get_all_play_session_infos(
            self.game, self.version
        )
        statuses.sort(key=lambda x: x[1]["time"], reverse=True)

        # Cap all comment blocks to the limit
        if limit >= 0:
            comments = comments[:limit]
            statuses = statuses[:limit]

        # Mapping of profiles to userIDs
        uid_mapping = {
            uid: prof
            for (uid, prof) in self.get_any_profiles(
                [c[0] for c in comments] + [s[0] for s in statuses]
            )
        }

        # Mapping of location ID to machine name
        lid_mapping: Dict[int, str] = {}

        root = Node.void("event_r")
        root.add_child(Node.s32("time", Time.now()))
        statusnode = Node.void("status")
        root.add_child(statusnode)
        commentnode = Node.void("comment")
        root.add_child(commentnode)

        for uid, comment in comments:
            lid = ID.parse_machine_id(comment.data.get_str("lid"))

            # Look up external data for the request
            if lid not in lid_mapping:
                machine = self.get_machine_by_id(lid)
                if machine is not None:
                    lid_mapping[lid] = machine.name
                else:
                    lid_mapping[lid] = ""

            c = Node.void("c")
            commentnode.add_child(c)
            c.add_child(Node.s32("uid", uid_mapping[uid].extid))
            c.add_child(Node.string("p_name", uid_mapping[uid].get_str("name")))
            c.add_child(Node.s32("exp", uid_mapping[uid].get_int("exp")))
            c.add_child(Node.s32("customize", comment.data.get_int("customize")))
            c.add_child(Node.s32("tid", comment.data.get_int("teamid")))
            c.add_child(Node.string("t_name", comment.data.get_str("teamname")))
            c.add_child(Node.string("lid", comment.data.get_str("lid")))
            c.add_child(Node.string("s_name", lid_mapping[lid]))
            c.add_child(Node.s8("pref", comment.data.get_int("prefecture")))
            c.add_child(Node.s32("time", comment.timestamp))
            c.add_child(Node.string("comment", comment.data.get_str("comment")))
            c.add_child(Node.bool("is_tweet", comment.data.get_bool("tweet")))

        for uid, status in statuses:
            lid = ID.parse_machine_id(status.get_str("lid"))

            # Look up external data for the request
            if lid not in lid_mapping:
                machine = self.get_machine_by_id(lid)
                if machine is not None:
                    lid_mapping[lid] = machine.name
                else:
                    lid_mapping[lid] = ""

            s = Node.void("s")
            statusnode.add_child(s)
            s.add_child(Node.s32("uid", uid_mapping[uid].extid))
            s.add_child(Node.string("p_name", uid_mapping[uid].get_str("name")))
            s.add_child(Node.s32("exp", uid_mapping[uid].get_int("exp")))
            s.add_child(Node.s32("customize", status.get_int("customize")))
            s.add_child(Node.s32("tid", uid_mapping[uid].get_int("team_id", -1)))
            s.add_child(
                Node.string("t_name", uid_mapping[uid].get_str("team_name", ""))
            )
            s.add_child(Node.string("lid", status.get_str("lid")))
            s.add_child(Node.string("s_name", lid_mapping[lid]))
            s.add_child(Node.s8("pref", status.get_int("prefecture")))
            s.add_child(Node.s32("time", status.get_int("time")))
            s.add_child(Node.s8("status", status.get_int("status")))
            s.add_child(Node.s8("stage", status.get_int("stage")))
            s.add_child(Node.s32("mid", status.get_int("mid")))
            s.add_child(Node.s8("ng", status.get_int("ng")))

        return root

    def handle_event_w_add_comment_request(self, request: Node) -> Node:
        extid = request.child_value("uid")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is None:
            # Anonymous comment
            userid = UserID(0)

        customize = request.child_value("customize")
        lid = request.child_value("lid")
        teamid = request.child_value("tid")
        teamname = request.child_value("t_name")
        prefecture = request.child_value("pref")
        comment = request.child_value("comment")
        is_tweet = request.child_value("is_tweet")

        # Link comment to user's profile
        self.data.local.user.put_time_based_achievement(
            self.game,
            self.version,
            userid,
            0,  # We never have an ID for this, since comments are add-only
            "puzzle_comment",
            {
                "customize": customize,
                "lid": lid,
                "teamid": teamid,
                "teamname": teamname,
                "prefecture": prefecture,
                "comment": comment,
                "tweet": is_tweet,
            },
        )

        return Node.void("event_w")

    def handle_event_w_update_status_request(self, request: Node) -> Node:
        # Update user status so puzzle comments can show it
        extid = request.child_value("uid")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is not None:
            customize = request.child_value("customize")
            status = request.child_value("status")
            stage = request.child_value("stage")
            mid = request.child_value("mid")
            ng = request.child_value("ng")
            lid = request.child_value("lid")
            prefecture = request.child_value("pref")

            self.data.local.lobby.put_play_session_info(
                self.game,
                self.version,
                userid,
                {
                    "customize": customize,
                    "status": status,
                    "stage": stage,
                    "mid": mid,
                    "ng": ng,
                    "lid": lid,
                    "prefecture": prefecture,
                },
            )
        return Node.void("event_w")

    def handle_lobby_entry_request(self, request: Node) -> Node:
        root = Node.void("lobby")
        root.add_child(Node.s32("interval", 120))
        root.add_child(Node.s32("interval_p", 120))

        # Create a lobby entry for this user
        extid = request.child_value("e/uid")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is not None:
            profile = self.get_profile(userid)
            self.data.local.lobby.put_lobby(
                self.game,
                self.version,
                userid,
                {
                    "mid": request.child_value("e/mid"),
                    "ng": request.child_value("e/ng"),
                    "mopt": request.child_value("e/mopt"),
                    "tid": request.child_value("e/tid"),
                    "tn": request.child_value("e/tn"),
                    "topt": request.child_value("e/topt"),
                    "lid": request.child_value("e/lid"),
                    "sn": request.child_value("e/sn"),
                    "pref": request.child_value("e/pref"),
                    "stg": request.child_value("e/stg"),
                    "pside": request.child_value("e/pside"),
                    "eatime": request.child_value("e/eatime"),
                    "ga": request.child_value("e/ga"),
                    "gp": request.child_value("e/gp"),
                    "la": request.child_value("e/la"),
                },
            )
            lobby = self.data.local.lobby.get_lobby(
                self.game,
                self.version,
                userid,
            )
            root.add_child(Node.s32("eid", lobby.get_int("id")))
            e = Node.void("e")
            root.add_child(e)
            e.add_child(Node.s32("eid", lobby.get_int("id")))
            e.add_child(Node.u16("mid", lobby.get_int("mid")))
            e.add_child(Node.u8("ng", lobby.get_int("ng")))
            e.add_child(Node.s32("uid", profile.extid))
            e.add_child(Node.string("pn", profile.get_str("name")))
            e.add_child(Node.s32("uattr", profile.get_int("uattr")))
            e.add_child(Node.s32("mopt", lobby.get_int("mopt")))
            e.add_child(Node.s16("mg", profile.get_int("mg")))
            e.add_child(Node.s32("tid", lobby.get_int("tid")))
            e.add_child(Node.string("tn", lobby.get_str("tn")))
            e.add_child(Node.s32("topt", lobby.get_int("topt")))
            e.add_child(Node.string("lid", lobby.get_str("lid")))
            e.add_child(Node.string("sn", lobby.get_str("sn")))
            e.add_child(Node.u8("pref", lobby.get_int("pref")))
            e.add_child(Node.s8("stg", lobby.get_int("stg")))
            e.add_child(Node.s8("pside", lobby.get_int("pside")))
            e.add_child(Node.s16("eatime", lobby.get_int("eatime")))
            e.add_child(Node.u8_array("ga", lobby.get_int_array("ga", 4)))
            e.add_child(Node.u16("gp", lobby.get_int("gp")))
            e.add_child(Node.u8_array("la", lobby.get_int_array("la", 4)))

        return root

    def handle_lobby_read_request(self, request: Node) -> Node:
        root = Node.void("lobby")
        root.add_child(Node.s32("interval", 120))
        root.add_child(Node.s32("interval_p", 120))

        # Look up all lobbies matching the criteria specified
        mg = request.child_value("m_grade")  # noqa: F841
        extid = request.child_value("uid")
        limit = request.child_value("max")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is not None:
            lobbies = self.data.local.lobby.get_all_lobbies(self.game, self.version)
            for user, lobby in lobbies:
                if limit <= 0:
                    break

                if user == userid:
                    # If we have our own lobby, don't return it
                    continue

                profile = self.get_profile(user)
                if profile is None:
                    # No profile info, don't return this lobby
                    continue

                e = Node.void("e")
                root.add_child(e)
                e.add_child(Node.s32("eid", lobby.get_int("id")))
                e.add_child(Node.u16("mid", lobby.get_int("mid")))
                e.add_child(Node.u8("ng", lobby.get_int("ng")))
                e.add_child(Node.s32("uid", profile.extid))
                e.add_child(Node.string("pn", profile.get_str("name")))
                e.add_child(Node.s32("uattr", profile.get_int("uattr")))
                e.add_child(Node.s32("mopt", lobby.get_int("mopt")))
                e.add_child(Node.s16("mg", profile.get_int("mg")))
                e.add_child(Node.s32("tid", lobby.get_int("tid")))
                e.add_child(Node.string("tn", lobby.get_str("tn")))
                e.add_child(Node.s32("topt", lobby.get_int("topt")))
                e.add_child(Node.string("lid", lobby.get_str("lid")))
                e.add_child(Node.string("sn", lobby.get_str("sn")))
                e.add_child(Node.u8("pref", lobby.get_int("pref")))
                e.add_child(Node.s8("stg", lobby.get_int("stg")))
                e.add_child(Node.s8("pside", lobby.get_int("pside")))
                e.add_child(Node.s16("eatime", lobby.get_int("eatime")))
                e.add_child(Node.u8_array("ga", lobby.get_int_array("ga", 4)))
                e.add_child(Node.u16("gp", lobby.get_int("gp")))
                e.add_child(Node.u8_array("la", lobby.get_int_array("la", 4)))

                limit = limit - 1

        return root

    def handle_lobby_delete_request(self, request: Node) -> Node:
        eid = request.child_value("eid")
        self.data.local.lobby.destroy_lobby(eid)
        return Node.void("lobby")

    def handle_player_start_request(self, request: Node) -> Node:
        # Add a dummy entry into the lobby setup so we can clean up on end play
        refid = request.child_value("rid")
        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is not None:
            self.data.local.lobby.put_play_session_info(
                self.game, self.version, userid, {}
            )

        root = Node.void("player")
        root.add_child(Node.bool("is_suc", True))

        unlock_music = Node.void("unlock_music")
        root.add_child(unlock_music)
        unlock_item = Node.void("unlock_item")
        root.add_child(unlock_item)
        item_lock_ctrl = Node.void("item_lock_ctrl")
        root.add_child(item_lock_ctrl)

        lincle_link_4 = Node.void("lincle_link_4")
        root.add_child(lincle_link_4)
        lincle_link_4.add_child(Node.u32("qpro", 0))
        lincle_link_4.add_child(Node.u32("glass", 0))
        lincle_link_4.add_child(Node.u32("treasure", 0))
        lincle_link_4.add_child(Node.bool("for_iidx_0_0", False))
        lincle_link_4.add_child(Node.bool("for_iidx_0_1", False))
        lincle_link_4.add_child(Node.bool("for_iidx_0_2", False))
        lincle_link_4.add_child(Node.bool("for_iidx_0_3", False))
        lincle_link_4.add_child(Node.bool("for_iidx_0_4", False))
        lincle_link_4.add_child(Node.bool("for_iidx_0_5", False))
        lincle_link_4.add_child(Node.bool("for_iidx_0_6", False))
        lincle_link_4.add_child(Node.bool("for_iidx_0", False))
        lincle_link_4.add_child(Node.bool("for_iidx_1", False))
        lincle_link_4.add_child(Node.bool("for_iidx_2", False))
        lincle_link_4.add_child(Node.bool("for_iidx_3", False))
        lincle_link_4.add_child(Node.bool("for_iidx_4", False))
        lincle_link_4.add_child(Node.bool("for_rb_0_0", False))
        lincle_link_4.add_child(Node.bool("for_rb_0_1", False))
        lincle_link_4.add_child(Node.bool("for_rb_0_2", False))
        lincle_link_4.add_child(Node.bool("for_rb_0_3", False))
        lincle_link_4.add_child(Node.bool("for_rb_0_4", False))
        lincle_link_4.add_child(Node.bool("for_rb_0_5", False))
        lincle_link_4.add_child(Node.bool("for_rb_0_6", False))
        lincle_link_4.add_child(Node.bool("for_rb_0", False))
        lincle_link_4.add_child(Node.bool("for_rb_1", False))
        lincle_link_4.add_child(Node.bool("for_rb_2", False))
        lincle_link_4.add_child(Node.bool("for_rb_3", False))
        lincle_link_4.add_child(Node.bool("for_rb_4", False))
        lincle_link_4.add_child(Node.bool("qproflg", False))
        lincle_link_4.add_child(Node.bool("glassflg", False))
        lincle_link_4.add_child(Node.bool("complete", False))

        # Add event info
        self.__add_event_info(root)

        return root

    def handle_player_delete_request(self, request: Node) -> Node:
        return Node.void("player")

    def handle_player_end_request(self, request: Node) -> Node:
        # Destroy play session based on info from the request
        refid = request.child_value("rid")
        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is not None:
            # Kill any lingering lobbies by this user
            lobby = self.data.local.lobby.get_lobby(
                self.game,
                self.version,
                userid,
            )
            if lobby is not None:
                self.data.local.lobby.destroy_lobby(lobby.get_int("id"))
            self.data.local.lobby.destroy_play_session_info(
                self.game, self.version, userid
            )

        return Node.void("player")

    def handle_player_read_request(self, request: Node) -> Node:
        refid = request.child_value("rid")
        profile = self.get_profile_by_refid(refid)
        if profile:
            return profile
        return Node.void("player")

    def handle_player_write_request(self, request: Node) -> Node:
        refid = request.child_value("rid")
        profile = self.put_profile_by_refid(refid, request)
        root = Node.void("player")

        if profile is None:
            root.add_child(Node.s32("uid", 0))
        else:
            root.add_child(Node.s32("uid", profile.extid))
        root.add_child(Node.s32("time", Time.now()))
        return root

    def handle_player_succeed_request(self, request: Node) -> Node:
        refid = request.child_value("rid")
        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is not None:
            previous_version = self.previous_version()
            profile = previous_version.get_profile(userid)
            achievements = self.data.local.user.get_achievements(
                previous_version.game, previous_version.version, userid
            )
            scores = self.data.remote.music.get_scores(
                previous_version.game, previous_version.version, userid
            )
        else:
            profile = None

        root = Node.void("player")

        if profile is None:
            root.add_child(Node.string("name", ""))
            root.add_child(Node.s32("lv", -1))
            root.add_child(Node.s32("exp", -1))
            root.add_child(Node.s32("grade", -1))
            root.add_child(Node.s32("ap", -1))

            root.add_child(Node.void("released"))
            root.add_child(Node.void("mrecord"))
        else:
            root.add_child(Node.string("name", profile.get_str("name")))
            root.add_child(Node.s32("lv", profile.get_int("lvl")))
            root.add_child(Node.s32("exp", profile.get_int("exp")))
            root.add_child(Node.s32("grade", profile.get_int("mg")))  # This is a guess
            root.add_child(Node.s32("ap", profile.get_int("ap")))

            released = Node.void("released")
            root.add_child(released)
            for item in achievements:
                if item.type != "item_0":
                    continue

                released.add_child(Node.s16("i", item.id))

            mrecord = Node.void("mrecord")
            root.add_child(mrecord)
            for score in scores:
                mrec = Node.void("mrec")
                mrecord.add_child(mrec)
                mrec.add_child(Node.s32("mid", score.id))
                mrec.add_child(Node.s32("ctype", score.chart))
                mrec.add_child(
                    Node.s32("win", score.data.get_dict("stats").get_int("win"))
                )
                mrec.add_child(
                    Node.s32("lose", score.data.get_dict("stats").get_int("win"))
                )
                mrec.add_child(
                    Node.s32("draw", score.data.get_dict("stats").get_int("win"))
                )
                mrec.add_child(Node.s32("score", score.points))
                mrec.add_child(Node.s32("combo", score.data.get_int("combo")))
                mrec.add_child(Node.s32("miss", score.data.get_int("miss_count")))
                mrec.add_child(
                    Node.s32(
                        "grade",
                        self.__db_to_game_clear_type(
                            score.data.get_int("clear_type"),
                            score.data.get_int("combo_type"),
                        ),
                    )
                )
                mrec.add_child(Node.s32("ap", score.data.get_int("achievement_rate")))

        return root

    def format_profile(self, userid: UserID, profile: Profile) -> Node:
        statistics = self.get_play_statistics(userid)
        game_config = self.get_game_config()
        achievements = self.data.local.user.get_achievements(
            self.game, self.version, userid
        )
        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
        links = self.data.local.user.get_links(self.game, self.version, userid)
        root = Node.void("player")
        pdata = Node.void("pdata")
        root.add_child(pdata)

        base = Node.void("base")
        pdata.add_child(base)
        base.add_child(Node.s32("uid", profile.extid))
        base.add_child(Node.string("name", profile.get_str("name")))
        base.add_child(Node.s16("icon_id", profile.get_int("icon")))
        base.add_child(Node.s16("lv", profile.get_int("lvl")))
        base.add_child(Node.s32("exp", profile.get_int("exp")))
        base.add_child(Node.s16("mg", profile.get_int("mg")))
        base.add_child(Node.s16("ap", profile.get_int("ap")))
        base.add_child(Node.s32("pc", profile.get_int("pc")))
        base.add_child(Node.s32("uattr", profile.get_int("uattr")))

        con = Node.void("con")
        pdata.add_child(con)
        con.add_child(Node.s32("day", statistics.today_plays))
        con.add_child(Node.s32("cnt", statistics.total_plays))
        con.add_child(Node.s32("total_cnt", statistics.total_plays))
        con.add_child(Node.s32("last", statistics.last_play_timestamp))
        con.add_child(Node.s32("now", Time.now()))

        team = Node.void("team")
        pdata.add_child(team)
        team.add_child(Node.s32("id", profile.get_int("team_id", -1)))
        team.add_child(Node.string("name", profile.get_str("team_name", "")))

        custom = Node.void("custom")
        customdict = profile.get_dict("custom")
        pdata.add_child(custom)
        custom.add_child(Node.u8("s_gls", customdict.get_int("s_gls")))
        custom.add_child(Node.u8("bgm_m", customdict.get_int("bgm_m")))
        custom.add_child(Node.u8("st_f", customdict.get_int("st_f")))
        custom.add_child(Node.u8("st_bg", customdict.get_int("st_bg")))
        custom.add_child(Node.u8("st_bg_b", customdict.get_int("st_bg_b")))
        custom.add_child(Node.u8("eff_e", customdict.get_int("eff_e")))
        custom.add_child(Node.u8("se_s", customdict.get_int("se_s")))
        custom.add_child(Node.u8("se_s_v", customdict.get_int("se_s_v")))
        custom.add_child(Node.s16("last_music_id", customdict.get_int("last_music_id")))
        custom.add_child(
            Node.u8("last_note_grade", customdict.get_int("last_note_grade"))
        )
        custom.add_child(Node.u8("sort_type", customdict.get_int("sort_type")))
        custom.add_child(
            Node.u8("narrowdown_type", customdict.get_int("narrowdown_type"))
        )
        custom.add_child(
            Node.bool("is_begginer", customdict.get_bool("is_begginer"))
        )  # Yes, this is spelled right
        custom.add_child(Node.bool("is_tut", customdict.get_bool("is_tut")))
        custom.add_child(
            Node.s16_array(
                "symbol_chat_0", customdict.get_int_array("symbol_chat_0", 6)
            )
        )
        custom.add_child(
            Node.s16_array(
                "symbol_chat_1", customdict.get_int_array("symbol_chat_1", 6)
            )
        )
        custom.add_child(Node.u8("gauge_style", customdict.get_int("gauge_style")))
        custom.add_child(Node.u8("obj_shade", customdict.get_int("obj_shade")))
        custom.add_child(Node.u8("obj_size", customdict.get_int("obj_size")))
        custom.add_child(
            Node.s16_array("byword", customdict.get_int_array("byword", 2))
        )
        custom.add_child(
            Node.bool_array(
                "is_auto_byword", customdict.get_bool_array("is_auto_byword", 2)
            )
        )
        custom.add_child(Node.bool("is_tweet", customdict.get_bool("is_tweet")))
        custom.add_child(
            Node.bool("is_link_twitter", customdict.get_bool("is_link_twitter"))
        )
        custom.add_child(Node.s16("mrec_type", customdict.get_int("mrec_type")))
        custom.add_child(
            Node.s16("card_disp_type", customdict.get_int("card_disp_type"))
        )
        custom.add_child(Node.s16("tab_sel", customdict.get_int("tab_sel")))
        custom.add_child(
            Node.s32_array("hidden_param", customdict.get_int_array("hidden_param", 20))
        )

        released = Node.void("released")
        pdata.add_child(released)

        for item in achievements:
            if item.type[:5] != "item_":
                continue
            itemtype = int(item.type[5:])
            if game_config.get_bool("force_unlock_songs") and itemtype == 0:
                # Don't echo unlocks when we're force unlocking, we'll do it later
                continue

            info = Node.void("info")
            released.add_child(info)
            info.add_child(Node.u8("type", itemtype))
            info.add_child(Node.u16("id", item.id))
            info.add_child(Node.u16("param", item.data.get_int("param")))

        if game_config.get_bool("force_unlock_songs"):
            ids: Dict[int, int] = {}
            songs = self.data.local.music.get_all_songs(self.game, self.version)
            for song in songs:
                if song.id not in ids:
                    ids[song.id] = 0

                if song.data.get_int("difficulty") > 0:
                    ids[song.id] = ids[song.id] | (1 << song.chart)

            for songid in ids:
                if ids[songid] == 0:
                    continue

                info = Node.void("info")
                released.add_child(info)
                info.add_child(Node.u8("type", 0))
                info.add_child(Node.u16("id", songid))
                info.add_child(Node.u16("param", ids[songid]))

        # Scores
        record = Node.void("record")
        pdata.add_child(record)

        for score in scores:
            rec = Node.void("rec")
            record.add_child(rec)
            rec.add_child(Node.u16("mid", score.id))
            rec.add_child(Node.u8("ng", score.chart))
            rec.add_child(
                Node.s32("point", score.data.get_dict("stats").get_int("earned_points"))
            )
            rec.add_child(Node.s32("played_time", score.timestamp))

            mrec_0 = Node.void("mrec_0")
            rec.add_child(mrec_0)
            mrec_0.add_child(
                Node.s32("win", score.data.get_dict("stats").get_int("win"))
            )
            mrec_0.add_child(
                Node.s32("lose", score.data.get_dict("stats").get_int("lose"))
            )
            mrec_0.add_child(
                Node.s32("draw", score.data.get_dict("stats").get_int("draw"))
            )
            mrec_0.add_child(
                Node.u8(
                    "ct",
                    self.__db_to_game_clear_type(
                        score.data.get_int("clear_type"),
                        score.data.get_int("combo_type"),
                    ),
                )
            )
            mrec_0.add_child(
                Node.s16("ar", int(score.data.get_int("achievement_rate") / 10))
            )
            mrec_0.add_child(Node.s32("bs", score.points))
            mrec_0.add_child(Node.s16("mc", score.data.get_int("combo")))
            mrec_0.add_child(Node.s16("bmc", score.data.get_int("miss_count")))

            mrec_1 = Node.void("mrec_1")
            rec.add_child(mrec_1)
            mrec_1.add_child(Node.s32("win", 0))
            mrec_1.add_child(Node.s32("lose", 0))
            mrec_1.add_child(Node.s32("draw", 0))
            mrec_1.add_child(Node.u8("ct", 0))
            mrec_1.add_child(Node.s16("ar", 0))
            mrec_1.add_child(Node.s32("bs", 0))
            mrec_1.add_child(Node.s16("mc", 0))
            mrec_1.add_child(Node.s16("bmc", -1))

        # Comment (seems unused?)
        pdata.add_child(Node.string("cmnt", ""))

        # Rivals
        rival = Node.void("rival")
        pdata.add_child(rival)

        slotid = 0
        for link in links:
            if link.type != "rival":
                continue

            rprofile = self.get_profile(link.other_userid)
            if rprofile is None:
                continue

            r = Node.void("r")
            rival.add_child(r)
            r.add_child(Node.u8("slot_id", slotid))
            r.add_child(Node.string("name", rprofile.get_str("name")))
            r.add_child(Node.s32("id", rprofile.extid))
            r.add_child(Node.bool("friend", True))
            r.add_child(Node.bool("locked", False))
            r.add_child(Node.s32("rc", 0))
            slotid = slotid + 1

        # Glass points
        glass = Node.void("glass")
        pdata.add_child(glass)

        for item in achievements:
            if item.type != "glass":
                continue

            g = Node.void("g")
            glass.add_child(g)
            g.add_child(Node.s32("id", item.id))
            g.add_child(Node.s32("exp", item.data.get_int("exp")))

        # Favorite music
        fav_music_slot = Node.void("fav_music_slot")
        pdata.add_child(fav_music_slot)

        for item in achievements:
            if item.type != "music":
                continue

            slot = Node.void("slot")
            fav_music_slot.add_child(slot)
            slot.add_child(Node.u8("slot_id", item.id))
            slot.add_child(Node.s16("music_id", item.data.get_int("music_id")))

        narrow_down = Node.void("narrow_down")
        pdata.add_child(narrow_down)
        narrow_down.add_child(
            Node.s32_array(
                "adv_param",
                [
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                ],
            )
        )

        return root

    def unformat_profile(
        self, userid: UserID, request: Node, oldprofile: Profile
    ) -> Profile:
        game_config = self.get_game_config()
        newprofile = oldprofile.clone()

        newprofile.replace_int("lid", ID.parse_machine_id(request.child_value("lid")))
        newprofile.replace_str("name", request.child_value("pdata/base/name"))
        newprofile.replace_int("icon", request.child_value("pdata/base/icon_id"))
        newprofile.replace_int("lvl", request.child_value("pdata/base/lv"))
        newprofile.replace_int("exp", request.child_value("pdata/base/exp"))
        newprofile.replace_int("mg", request.child_value("pdata/base/mg"))
        newprofile.replace_int("ap", request.child_value("pdata/base/ap"))
        newprofile.replace_int("pc", request.child_value("pdata/base/pc"))
        newprofile.replace_int("uattr", request.child_value("pdata/base/uattr"))

        customdict = newprofile.get_dict("custom")
        custom = request.child("pdata/custom")
        if custom:
            customdict.replace_int("s_gls", custom.child_value("s_gls"))
            customdict.replace_int("bgm_m", custom.child_value("bgm_m"))
            customdict.replace_int("st_f", custom.child_value("st_f"))
            customdict.replace_int("st_bg", custom.child_value("st_bg"))
            customdict.replace_int("st_bg_b", custom.child_value("st_bg_b"))
            customdict.replace_int("eff_e", custom.child_value("eff_e"))
            customdict.replace_int("se_s", custom.child_value("se_s"))
            customdict.replace_int("se_s_v", custom.child_value("se_s_v"))
            customdict.replace_int("last_music_id", custom.child_value("last_music_id"))
            customdict.replace_int(
                "last_note_grade", custom.child_value("last_note_grade")
            )
            customdict.replace_int("sort_type", custom.child_value("sort_type"))
            customdict.replace_int(
                "narrowdown_type", custom.child_value("narrowdown_type")
            )
            customdict.replace_bool(
                "is_begginer", custom.child_value("is_begginer")
            )  # Yes, this is spelled right
            customdict.replace_bool("is_tut", custom.child_value("is_tut"))
            customdict.replace_int_array(
                "symbol_chat_0", 6, custom.child_value("symbol_chat_0")
            )
            customdict.replace_int_array(
                "symbol_chat_1", 6, custom.child_value("symbol_chat_1")
            )
            customdict.replace_int("gauge_style", custom.child_value("gauge_style"))
            customdict.replace_int("obj_shade", custom.child_value("obj_shade"))
            customdict.replace_int("obj_size", custom.child_value("obj_size"))
            customdict.replace_int_array("byword", 2, custom.child_value("byword"))
            customdict.replace_bool_array(
                "is_auto_byword", 2, custom.child_value("is_auto_byword")
            )
            customdict.replace_bool("is_tweet", custom.child_value("is_tweet"))
            customdict.replace_bool(
                "is_link_twitter", custom.child_value("is_link_twitter")
            )
            customdict.replace_int("mrec_type", custom.child_value("mrec_type"))
            customdict.replace_int(
                "card_disp_type", custom.child_value("card_disp_type")
            )
            customdict.replace_int("tab_sel", custom.child_value("tab_sel"))
            customdict.replace_int_array(
                "hidden_param", 20, custom.child_value("hidden_param")
            )
        newprofile.replace_dict("custom", customdict)

        # Music unlocks and other stuff
        released = request.child("pdata/released")
        if released:
            for child in released.children:
                if child.name != "info":
                    continue

                item_id = child.child_value("id")
                item_type = child.child_value("type")
                param = child.child_value("param")
                if game_config.get_bool("force_unlock_songs") and item_type == 0:
                    # Don't save unlocks when we're force unlocking
                    continue

                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    item_id,
                    f"item_{item_type}",
                    {
                        "param": param,
                    },
                )

        # Grab any new records set during this play session. Reflec Beat Limelight only sends
        # the top record back for songs that were played at least once during the session.
        # Note that it sends the top record, so if you play the song twice, it will return
        # only one record. Also, if you get a lower score than a previous try, it will return
        # the previous try. So, we must also look at the battle log for the actual play scores,
        # and combine the data if we can.
        savedrecords: Dict[int, Dict[int, Dict[str, int]]] = {}
        songplays = request.child("pdata/record")
        if songplays:
            for child in songplays.children:
                if child.name != "rec":
                    continue

                songid = child.child_value("mid")
                chart = child.child_value("ng")

                # These don't get sent with the battle logs, so we try to construct
                # the values here.
                if songid not in savedrecords:
                    savedrecords[songid] = {}
                savedrecords[songid][chart] = {
                    "achievement_rate": child.child_value("mrec_0/ar") * 10,
                    "points": child.child_value("mrec_0/bs"),
                    "combo": child.child_value("mrec_0/mc"),
                    "miss_count": child.child_value("mrec_0/bmc"),
                    "win": child.child_value("mrec_0/win"),
                    "lose": child.child_value("mrec_0/lose"),
                    "draw": child.child_value("mrec_0/draw"),
                    "earned_points": child.child_value("point"),
                }

        # Now, see the actual battles that were played. If we can, unify the data with a record.
        # We only do that when the record achievement rate and score matches the battle achievement
        # rate and score, so we know for a fact that that record was generated by this battle.
        battlelogs = request.child("pdata/blog")
        if battlelogs:
            for child in battlelogs.children:
                if child.name != "log":
                    continue

                songid = child.child_value("mid")
                chart = child.child_value("ng")

                clear_type = child.child_value("myself/ct")
                achievement_rate = child.child_value("myself/ar") * 10
                points = child.child_value("myself/s")

                clear_type, combo_type = self.__game_to_db_clear_type(clear_type)

                combo = None
                miss_count = -1
                stats = None

                if songid in savedrecords:
                    if chart in savedrecords[songid]:
                        data = savedrecords[songid][chart]

                        if (
                            data["achievement_rate"] == achievement_rate
                            and data["points"] == points
                        ):
                            # This is the same record! Use the stats from it to update our
                            # internal representation.
                            combo = data["combo"]
                            miss_count = data["miss_count"]
                            stats = {
                                "win": data["win"],
                                "lose": data["lose"],
                                "draw": data["draw"],
                                "earned_points": data["earned_points"],
                            }

                self.update_score(
                    userid,
                    songid,
                    chart,
                    points,
                    achievement_rate,
                    clear_type,
                    combo_type,
                    miss_count,
                    combo=combo,
                    stats=stats,
                )

        # Keep track of glass points so unlocks work
        glass = request.child("pdata/glass")
        if glass:
            for child in glass.children:
                if child.name != "g":
                    continue

                gid = child.child_value("id")
                exp = child.child_value("exp")
                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    gid,
                    "glass",
                    {
                        "exp": exp,
                    },
                )

        # Keep track of favorite music selections
        fav_music_slot = request.child("pdata/fav_music_slot")
        if fav_music_slot:
            for child in fav_music_slot.children:
                if child.name != "slot":
                    continue

                slot_id = child.child_value("slot_id")
                music_id = child.child_value("music_id")
                if music_id == -1:
                    # Delete this favorite
                    self.data.local.user.destroy_achievement(
                        self.game,
                        self.version,
                        userid,
                        slot_id,
                        "music",
                    )
                else:
                    # Add/update this favorite
                    self.data.local.user.put_achievement(
                        self.game,
                        self.version,
                        userid,
                        slot_id,
                        "music",
                        {
                            "music_id": music_id,
                        },
                    )

        # Keep track of play statistics
        self.update_play_statistics(userid)

        return newprofile