from typing import Any, Dict, List, Optional

from bemani.backend.reflec.base import ReflecBeatBase
from bemani.backend.reflec.volzzabase import ReflecBeatVolzzaBase
from bemani.backend.reflec.groovin import ReflecBeatGroovin

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


class ReflecBeatVolzza(ReflecBeatVolzzaBase):
    name: str = "REFLEC BEAT VOLZZA"
    version: int = VersionConstants.REFLEC_BEAT_VOLZZA

    def previous_version(self) -> Optional[ReflecBeatBase]:
        return ReflecBeatGroovin(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 _add_event_info(self, root: Node) -> None:
        event_ctrl = Node.void("event_ctrl")
        root.add_child(event_ctrl)
        # Contains zero or more nodes like:
        # <data>
        #     <type __type="s32">any</type>
        #     <index __type="s32">any</phase>
        #     <value __type="s32">any</phase>
        #     <value2 __type="s32">any</phase>
        #     <start_time __type="s32">any</phase>
        #     <end_time __type="s32">any</phase>
        # </data>

        item_lock_ctrl = Node.void("item_lock_ctrl")
        root.add_child(item_lock_ctrl)
        # Contains zero or more nodes like:
        # <item>
        #     <type __type="u8">any</type>
        #     <id __type="u16">any</id>
        #     <param __type="u16">0-3</param>
        # </item>

    def handle_player_rb5_player_read_score_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 None:
            scores: List[Score] = []
        else:
            scores = self.data.remote.music.get_scores(self.game, self.version, userid)

        root = Node.void("player")
        pdata = Node.void("pdata")
        root.add_child(pdata)

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

        for score in scores:
            rec = Node.void("rec")
            record.add_child(rec)
            rec.add_child(Node.s16("mid", score.id))
            rec.add_child(Node.s8("ntgrd", score.chart))
            rec.add_child(Node.s32("pc", score.plays))
            rec.add_child(
                Node.s8(
                    "ct", self._db_to_game_clear_type(score.data.get_int("clear_type"))
                )
            )
            rec.add_child(Node.s16("ar", score.data.get_int("achievement_rate")))
            rec.add_child(Node.s16("scr", score.points))
            rec.add_child(Node.s16("ms", score.data.get_int("miss_count")))
            rec.add_child(
                Node.s16(
                    "param",
                    self._db_to_game_combo_type(score.data.get_int("combo_type"))
                    + score.data.get_int("param"),
                )
            )
            rec.add_child(Node.s32("bscrt", score.timestamp))
            rec.add_child(
                Node.s32("bart", score.data.get_int("best_achievement_rate_time"))
            )
            rec.add_child(Node.s32("bctt", score.data.get_int("best_clear_type_time")))
            rec.add_child(Node.s32("bmst", score.data.get_int("best_miss_count_time")))
            rec.add_child(Node.s32("time", score.data.get_int("last_played_time")))
            rec.add_child(Node.s32("k_flag", score.data.get_int("kflag")))

        return root

    def handle_player_rb5_player_read_rival_score_request(self, request: Node) -> Node:
        extid = request.child_value("uid")
        songid = request.child_value("music_id")
        chart = request.child_value("note_grade")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is None:
            score = None
            profile = None
        else:
            score = self.data.remote.music.get_score(
                self.game, self.version, userid, songid, chart
            )
            profile = self.get_any_profile(userid)

        root = Node.void("player")
        if score is not None and profile is not None:
            player_select_score = Node.void("player_select_score")
            root.add_child(player_select_score)

            player_select_score.add_child(Node.s32("user_id", extid))
            player_select_score.add_child(Node.string("name", profile.get_str("name")))
            player_select_score.add_child(Node.s32("m_score", score.points))
            player_select_score.add_child(Node.s32("m_scoreTime", score.timestamp))
            player_select_score.add_child(
                Node.s16("m_iconID", profile.get_dict("config").get_int("icon_id"))
            )
        return root

    def handle_player_rb5_player_read_rival_ranking_data_request(
        self, request: Node
    ) -> Node:
        extid = request.child_value("uid")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)

        root = Node.void("player")
        rival_data = Node.void("rival_data")
        root.add_child(rival_data)

        if userid is not None:
            links = self.data.local.user.get_links(self.game, self.version, userid)
            for link in links:
                if link.type != "rival":
                    continue

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

                rl = Node.void("rl")
                rival_data.add_child(rl)
                rl.add_child(Node.s32("uid", rprofile.extid))
                rl.add_child(Node.string("nm", rprofile.get_str("name")))
                rl.add_child(
                    Node.s16("ic", rprofile.get_dict("config").get_int("icon_id"))
                )

                scores = self.data.remote.music.get_scores(
                    self.game, self.version, link.other_userid
                )
                scores_by_musicid: Dict[int, List[Score]] = {}
                for score in scores:
                    if score.id not in scores_by_musicid:
                        scores_by_musicid[score.id] = [None, None, None, None]
                    scores_by_musicid[score.id][score.chart] = score

                for mid, scores in scores_by_musicid.items():
                    points = [
                        score.points << 32 if score is not None else 0
                        for score in scores
                    ]
                    timestamps = [
                        score.timestamp if score is not None else 0 for score in scores
                    ]

                    sl = Node.void("sl")
                    rl.add_child(sl)
                    sl.add_child(Node.s16("mid", mid))
                    # Score, but shifted left 32 bits for no reason
                    sl.add_child(Node.u64_array("m", points))
                    # Timestamp of the clear
                    sl.add_child(Node.u64_array("t", timestamps))

        return root

    def handle_player_rb5_player_read_rank_request(self, request: Node) -> Node:
        # This gives us a 6-integer array mapping to user scores for the following:
        # [total score, basic chart score, medium chart score, hard chart score,
        # special chart score]. It also returns the previous rank, but this is
        # not used in-game as far as I can tell.
        current_scores = request.child_value("sc")
        current_minigame_score = request.child_value("mg_sc")

        # First, grab all scores on the network for this version.
        all_scores = self.data.remote.music.get_all_scores(self.game, self.version)

        # Now grab all participating users that had scores
        all_users = {userid for (userid, score) in all_scores}

        # Now, group the scores by user, so we can add up the totals, only including
        # scores where the user at least cleared the song.
        scores_by_user = {
            userid: [
                score
                for (uid, score) in all_scores
                if uid == userid
                and score.data.get_int("clear_type") >= self.CLEAR_TYPE_CLEARED
            ]
            for userid in all_users
        }

        # Now grab all user profiles for this game
        all_profiles = {
            profile[0]: profile[1]
            for profile in self.data.remote.user.get_all_profiles(
                self.game, self.version
            )
        }

        # Now, sum up the scores into the five categories that the game expects.
        total_scores = sorted(
            [
                sum([score.points for score in scores])
                for userid, scores in scores_by_user.items()
            ],
            reverse=True,
        )
        basic_scores = sorted(
            [
                sum(
                    [
                        score.points
                        for score in scores
                        if score.chart == self.CHART_TYPE_BASIC
                    ]
                )
                for userid, scores in scores_by_user.items()
            ],
            reverse=True,
        )
        medium_scores = sorted(
            [
                sum(
                    [
                        score.points
                        for score in scores
                        if score.chart == self.CHART_TYPE_MEDIUM
                    ]
                )
                for userid, scores in scores_by_user.items()
            ],
            reverse=True,
        )
        hard_scores = sorted(
            [
                sum(
                    [
                        score.points
                        for score in scores
                        if score.chart == self.CHART_TYPE_HARD
                    ]
                )
                for userid, scores in scores_by_user.items()
            ],
        )
        special_scores = sorted(
            [
                sum(
                    [
                        score.points
                        for score in scores
                        if score.chart == self.CHART_TYPE_SPECIAL
                    ]
                )
                for userid, scores in scores_by_user.items()
            ],
            reverse=True,
        )
        minigame_scores = sorted(
            [
                all_profiles.get(
                    userid, Profile(self.game, self.version, "", 0)
                ).get_int("mgsc")
                for userid in all_users
            ],
            reverse=True,
        )

        # Guarantee that a zero score is at the end of every list, so that it makes
        # the algorithm for figuring out place have no edge case.
        total_scores.append(0)
        basic_scores.append(0)
        medium_scores.append(0)
        hard_scores.append(0)
        special_scores.append(0)
        minigame_scores.append(0)

        # Now, figure out where we fit based on the scores sent from the game.
        user_place = [1, 1, 1, 1, 1, 1]
        which_score = [
            total_scores,
            basic_scores,
            medium_scores,
            hard_scores,
            special_scores,
            minigame_scores,
        ]
        earned_scores = current_scores + [current_minigame_score]
        for i in range(len(user_place)):
            earned_score = earned_scores[i]
            scores = which_score[i]
            for score in scores:
                if earned_score >= score:
                    break
                user_place[i] = user_place[i] + 1

        # Separate out minigame rank from scores
        minigame_rank = user_place[-1]
        user_place = user_place[:-1]

        root = Node.void("player")

        # Populate current ranking.
        tbs = Node.void("tbs")
        root.add_child(tbs)
        tbs.add_child(Node.s32_array("new_rank", user_place))
        tbs.add_child(Node.s32_array("old_rank", [-1, -1, -1, -1, -1]))

        # Populate current minigame ranking (LOL).
        mng = Node.void("mng")
        root.add_child(mng)
        mng.add_child(Node.s32("new_rank", minigame_rank))
        mng.add_child(Node.s32("old_rank", -1))

        return root

    def handle_player_rb5_player_write_request(self, request: Node) -> Node:
        refid = request.child_value("pdata/account/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))
        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
        )
        links = self.data.local.user.get_links(self.game, self.version, userid)
        root = Node.void("player")
        pdata = Node.void("pdata")
        root.add_child(pdata)

        # Previous account info
        previous_version = self.previous_version()
        if previous_version:
            succeeded = previous_version.has_profile(userid)
        else:
            succeeded = False

        # Account info
        account = Node.void("account")
        pdata.add_child(account)
        account.add_child(Node.s32("usrid", profile.extid))
        account.add_child(Node.s32("tpc", statistics.total_plays))
        account.add_child(Node.s32("dpc", statistics.today_plays))
        account.add_child(Node.s32("crd", 1))
        account.add_child(Node.s32("brd", 1))
        account.add_child(Node.s32("tdc", statistics.total_days))
        account.add_child(Node.s32("intrvld", 0))
        account.add_child(Node.s16("ver", 0))
        account.add_child(Node.u64("pst", 0))
        account.add_child(Node.u64("st", Time.now() * 1000))
        account.add_child(Node.bool("succeed", succeeded))
        account.add_child(Node.s32("opc", 0))
        account.add_child(Node.s32("lpc", 0))
        account.add_child(Node.s32("cpc", 0))

        # Base profile info
        base = Node.void("base")
        pdata.add_child(base)
        base.add_child(Node.string("name", profile.get_str("name")))
        base.add_child(Node.s32("mg", profile.get_int("mg")))
        base.add_child(Node.s32("ap", profile.get_int("ap")))
        base.add_child(Node.string("cmnt", ""))
        base.add_child(Node.s32("uattr", profile.get_int("uattr")))
        base.add_child(Node.s32("money", profile.get_int("money")))
        base.add_child(Node.s32("tbs", -1))
        base.add_child(Node.s32_array("tbgs", [-1, -1, -1, -1]))
        base.add_child(
            Node.s16_array(
                "mlog",
                [
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                    -1,
                ],
            )
        )
        base.add_child(Node.s32("class", profile.get_int("class")))
        base.add_child(Node.s32("class_ar", profile.get_int("class_ar")))

        # 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
            lobbyinfo = self.data.local.lobby.get_play_session_info(
                self.game, self.version, link.other_userid
            )
            if lobbyinfo is None:
                lobbyinfo = ValidatedDict()

            r = Node.void("r")
            rival.add_child(r)
            r.add_child(Node.s32("slot_id", slotid))
            r.add_child(Node.s32("id", rprofile.extid))
            r.add_child(Node.string("name", rprofile.get_str("name")))
            r.add_child(
                Node.s32("icon", rprofile.get_dict("config").get_int("icon_id"))
            )
            r.add_child(Node.s32("class", rprofile.get_int("class")))
            r.add_child(Node.s32("class_ar", rprofile.get_int("class_ar")))
            r.add_child(Node.bool("friend", True))
            r.add_child(Node.bool("target", False))
            r.add_child(Node.u32("time", lobbyinfo.get_int("time")))
            r.add_child(Node.u8_array("ga", lobbyinfo.get_int_array("ga", 4)))
            r.add_child(Node.u16("gp", lobbyinfo.get_int("gp")))
            r.add_child(Node.u8_array("ipn", lobbyinfo.get_int_array("la", 4)))
            r.add_child(Node.u8_array("pnid", lobbyinfo.get_int_array("pnid", 16)))
            slotid = slotid + 1

        # Configuration
        configdict = profile.get_dict("config")
        config = Node.void("config")
        pdata.add_child(config)
        config.add_child(Node.u8("msel_bgm", configdict.get_int("msel_bgm")))
        config.add_child(
            Node.u8("narrowdown_type", configdict.get_int("narrowdown_type"))
        )
        config.add_child(Node.s16("icon_id", configdict.get_int("icon_id")))
        config.add_child(Node.s16("byword_0", configdict.get_int("byword_0")))
        config.add_child(Node.s16("byword_1", configdict.get_int("byword_1")))
        config.add_child(
            Node.bool("is_auto_byword_0", configdict.get_bool("is_auto_byword_0"))
        )
        config.add_child(
            Node.bool("is_auto_byword_1", configdict.get_bool("is_auto_byword_1"))
        )
        config.add_child(Node.u8("mrec_type", configdict.get_int("mrec_type")))
        config.add_child(Node.u8("tab_sel", configdict.get_int("tab_sel")))
        config.add_child(Node.u8("card_disp", configdict.get_int("card_disp")))
        config.add_child(
            Node.u8("score_tab_disp", configdict.get_int("score_tab_disp"))
        )
        config.add_child(
            Node.s16("last_music_id", configdict.get_int("last_music_id", -1))
        )
        config.add_child(
            Node.u8("last_note_grade", configdict.get_int("last_note_grade"))
        )
        config.add_child(Node.u8("sort_type", configdict.get_int("sort_type")))
        config.add_child(
            Node.u8("rival_panel_type", configdict.get_int("rival_panel_type"))
        )
        config.add_child(
            Node.u64("random_entry_work", configdict.get_int("random_entry_work"))
        )
        config.add_child(
            Node.u64("custom_folder_work", configdict.get_int("custom_folder_work"))
        )
        config.add_child(Node.u8("folder_type", configdict.get_int("folder_type")))
        config.add_child(
            Node.u8("folder_lamp_type", configdict.get_int("folder_lamp_type"))
        )
        config.add_child(Node.bool("is_tweet", configdict.get_bool("is_tweet")))
        config.add_child(
            Node.bool("is_link_twitter", configdict.get_bool("is_link_twitter"))
        )

        # Customizations
        customdict = profile.get_dict("custom")
        custom = Node.void("custom")
        pdata.add_child(custom)
        custom.add_child(Node.u8("st_shot", customdict.get_int("st_shot")))
        custom.add_child(Node.u8("st_frame", customdict.get_int("st_frame")))
        custom.add_child(Node.u8("st_expl", customdict.get_int("st_expl")))
        custom.add_child(Node.u8("st_bg", customdict.get_int("st_bg")))
        custom.add_child(Node.u8("st_shot_vol", customdict.get_int("st_shot_vol")))
        custom.add_child(Node.u8("st_bg_bri", customdict.get_int("st_bg_bri")))
        custom.add_child(Node.u8("st_obj_size", customdict.get_int("st_obj_size")))
        custom.add_child(Node.u8("st_jr_gauge", customdict.get_int("st_jr_gauge")))
        custom.add_child(Node.u8("st_clr_gauge", customdict.get_int("st_clr_gauge")))
        custom.add_child(Node.u8("st_jdg_disp", customdict.get_int("st_jdg_disp")))
        custom.add_child(Node.u8("st_rnd", customdict.get_int("st_rnd")))
        custom.add_child(Node.u8("st_hazard", customdict.get_int("st_hazard")))
        custom.add_child(Node.u8("st_clr_cond", customdict.get_int("st_clr_cond")))
        custom.add_child(
            Node.u8("same_time_note_disp", customdict.get_int("same_time_note_disp"))
        )
        custom.add_child(
            Node.u8("st_gr_gauge_type", customdict.get_int("st_gr_gauge_type"))
        )
        custom.add_child(
            Node.s16("voice_message_set", customdict.get_int("voice_message_set", -1))
        )
        custom.add_child(
            Node.u8("voice_message_volume", customdict.get_int("voice_message_volume"))
        )

        # Unlocks
        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]))

        # Announcements
        announce = Node.void("announce")
        pdata.add_child(announce)

        for announcement in achievements:
            if announcement.type[:13] != "announcement_":
                continue
            announcementtype = int(announcement.type[13:])

            info = Node.void("info")
            announce.add_child(info)
            info.add_child(Node.u8("type", announcementtype))
            info.add_child(Node.u16("id", announcement.id))
            info.add_child(Node.u16("param", announcement.data.get_int("param")))
            info.add_child(
                Node.bool("bneedannounce", announcement.data.get_bool("need"))
            )

        # Dojo ranking return
        dojo = Node.void("dojo")
        pdata.add_child(dojo)

        for entry in achievements:
            if entry.type != "dojo":
                continue

            rec = Node.void("rec")
            dojo.add_child(rec)
            rec.add_child(Node.s32("class", entry.id))
            rec.add_child(Node.s32("clear_type", entry.data.get_int("clear_type")))
            rec.add_child(Node.s32("total_ar", entry.data.get_int("ar")))
            rec.add_child(Node.s32("total_score", entry.data.get_int("score")))
            rec.add_child(Node.s32("play_count", entry.data.get_int("plays")))
            rec.add_child(
                Node.s32("last_play_time", entry.data.get_int("play_timestamp"))
            )
            rec.add_child(
                Node.s32("record_update_time", entry.data.get_int("record_timestamp"))
            )
            rec.add_child(Node.s32("rank", 0))

        # Player Parameters
        player_param = Node.void("player_param")
        pdata.add_child(player_param)

        for param in achievements:
            if param.type[:13] != "player_param_":
                continue
            itemtype = int(param.type[13:])

            itemnode = Node.void("item")
            player_param.add_child(itemnode)
            itemnode.add_child(Node.s32("type", itemtype))
            itemnode.add_child(Node.s32("bank", param.id))
            itemnode.add_child(
                Node.s32_array("data", param.data.get_int_array("data", 256))
            )

        # Shop score for players
        self._add_shop_score(pdata)

        # My List data
        mylist = Node.void("mylist")
        pdata.add_child(mylist)
        listdata = Node.void("list")
        mylist.add_child(listdata)
        listdata.add_child(Node.s16("idx", 0))
        listdata.add_child(
            Node.s16_array("mlst", profile.get_int_array("favorites", 30, [-1] * 30))
        )

        # Minigame settings
        minigame = Node.void("minigame")
        pdata.add_child(minigame)
        minigame.add_child(Node.s8("mgid", profile.get_int("mgid")))
        minigame.add_child(Node.s32("sc", profile.get_int("mgsc")))

        # Derby settings
        derby = Node.void("derby")
        pdata.add_child(derby)
        derby.add_child(Node.bool("is_open", False))

        return root

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

        # Save base player profile info
        newprofile.replace_int(
            "lid", ID.parse_machine_id(request.child_value("pdata/account/lid"))
        )
        newprofile.replace_str("name", request.child_value("pdata/base/name"))
        newprofile.replace_int("mg", request.child_value("pdata/base/mg"))
        newprofile.replace_int("ap", request.child_value("pdata/base/ap"))
        newprofile.replace_int("uattr", request.child_value("pdata/base/uattr"))
        newprofile.replace_int("money", request.child_value("pdata/base/money"))
        newprofile.replace_int("class", request.child_value("pdata/base/class"))
        newprofile.replace_int("class_ar", request.child_value("pdata/base/class_ar"))
        newprofile.replace_int("mgid", request.child_value("pdata/minigame/mgid"))
        newprofile.replace_int("mgsc", request.child_value("pdata/minigame/sc"))
        newprofile.replace_int_array(
            "favorites", 30, request.child_value("pdata/mylist/list/mlst")
        )

        # Save player config
        configdict = newprofile.get_dict("config")
        config = request.child("pdata/config")
        if config:
            configdict.replace_int("msel_bgm", config.child_value("msel_bgm"))
            configdict.replace_int(
                "narrowdown_type", config.child_value("narrowdown_type")
            )
            configdict.replace_int("icon_id", config.child_value("icon_id"))
            configdict.replace_int("byword_0", config.child_value("byword_0"))
            configdict.replace_int("byword_1", config.child_value("byword_1"))
            configdict.replace_bool(
                "is_auto_byword_0", config.child_value("is_auto_byword_0")
            )
            configdict.replace_bool(
                "is_auto_byword_1", config.child_value("is_auto_byword_1")
            )
            configdict.replace_int("mrec_type", config.child_value("mrec_type"))
            configdict.replace_int("tab_sel", config.child_value("tab_sel"))
            configdict.replace_int("card_disp", config.child_value("card_disp"))
            configdict.replace_int(
                "score_tab_disp", config.child_value("score_tab_disp")
            )
            configdict.replace_int("last_music_id", config.child_value("last_music_id"))
            configdict.replace_int(
                "last_note_grade", config.child_value("last_note_grade")
            )
            configdict.replace_int("sort_type", config.child_value("sort_type"))
            configdict.replace_int(
                "rival_panel_type", config.child_value("rival_panel_type")
            )
            configdict.replace_int(
                "random_entry_work", config.child_value("random_entry_work")
            )
            configdict.replace_int(
                "custom_folder_work", config.child_value("custom_folder_work")
            )
            configdict.replace_int("folder_type", config.child_value("folder_type"))
            configdict.replace_int(
                "folder_lamp_type", config.child_value("folder_lamp_type")
            )
            configdict.replace_bool("is_tweet", config.child_value("is_tweet"))
            configdict.replace_bool(
                "is_link_twitter", config.child_value("is_link_twitter")
            )
        newprofile.replace_dict("config", configdict)

        # Save player custom settings
        customdict = newprofile.get_dict("custom")
        custom = request.child("pdata/custom")
        if custom:
            customdict.replace_int("st_shot", custom.child_value("st_shot"))
            customdict.replace_int("st_frame", custom.child_value("st_frame"))
            customdict.replace_int("st_expl", custom.child_value("st_expl"))
            customdict.replace_int("st_bg", custom.child_value("st_bg"))
            customdict.replace_int("st_shot_vol", custom.child_value("st_shot_vol"))
            customdict.replace_int("st_bg_bri", custom.child_value("st_bg_bri"))
            customdict.replace_int("st_obj_size", custom.child_value("st_obj_size"))
            customdict.replace_int("st_jr_gauge", custom.child_value("st_jr_gauge"))
            customdict.replace_int("st_clr_gauge", custom.child_value("st_clr_gauge"))
            customdict.replace_int("st_rnd", custom.child_value("st_rnd"))
            customdict.replace_int("st_hazard", custom.child_value("st_hazard"))
            customdict.replace_int("st_clr_cond", custom.child_value("st_clr_cond"))
            customdict.replace_int(
                "same_time_note_disp", custom.child_value("same_time_note_disp")
            )
            customdict.replace_int(
                "st_gr_gauge_type", custom.child_value("st_gr_gauge_type")
            )
            customdict.replace_int(
                "voice_message_set", custom.child_value("voice_message_set")
            )
            customdict.replace_int(
                "voice_message_volume", custom.child_value("voice_message_volume")
            )
        newprofile.replace_dict("custom", customdict)

        # Save player parameter info
        params = request.child("pdata/player_param")
        if params:
            for child in params.children:
                if child.name != "item":
                    continue

                item_type = child.child_value("type")
                bank = child.child_value("bank")
                data = child.child_value("data")
                while len(data) < 256:
                    data.append(0)
                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    bank,
                    f"player_param_{item_type}",
                    {
                        "data": data,
                    },
                )

        # Save player episode info
        episode = request.child("pdata/episode")
        if episode:
            for child in episode.children:
                if child.name != "info":
                    continue

                # I assume this is copypasta, but I want to be sure
                extid = child.child_value("user_id")
                if extid != newprofile.extid:
                    raise Exception(
                        f"Unexpected user ID, got {extid} expecting {newprofile.extid}"
                    )

                episode_type = child.child_value("type")
                episode_value0 = child.child_value("value0")
                episode_value1 = child.child_value("value1")
                episode_text = child.child_value("text")
                episode_time = child.child_value("time")
                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    episode_type,
                    "episode",
                    {
                        "value0": episode_value0,
                        "value1": episode_value1,
                        "text": episode_text,
                        "time": episode_time,
                    },
                )

        # Save released info
        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,
                    },
                )

        # Save announce info
        announce = request.child("pdata/announce")
        if announce:
            for child in announce.children:
                if child.name != "info":
                    continue

                announce_id = child.child_value("id")
                announce_type = child.child_value("type")
                param = child.child_value("param")
                need = child.child_value("bneedannounce")
                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    announce_id,
                    f"announcement_{announce_type}",
                    {
                        "param": param,
                        "need": need,
                    },
                )

        # Save player dojo
        dojo = request.child("pdata/dojo")
        if dojo:
            dojoid = dojo.child_value("class")
            clear_type = dojo.child_value("clear_type")
            ar = dojo.child_value("t_ar")
            score = dojo.child_value("t_score")

            # Figure out timestamp stuff
            data = (
                self.data.local.user.get_achievement(
                    self.game,
                    self.version,
                    userid,
                    dojoid,
                    "dojo",
                )
                or ValidatedDict()
            )

            if ar >= data.get_int("ar"):
                # We set a new achievement rate, keep the new values
                record_time = Time.now()
            else:
                # We didn't, keep the old values for achievement rate, but
                # override score and clear_type only if they were better.
                record_time = data.get_int("record_timestamp")
                ar = data.get_int("ar")
                score = max(score, data.get_int("score"))
                clear_type = max(clear_type, data.get_int("clear_type"))

            play_time = Time.now()
            plays = data.get_int("plays") + 1

            self.data.local.user.put_achievement(
                self.game,
                self.version,
                userid,
                dojoid,
                "dojo",
                {
                    "clear_type": clear_type,
                    "ar": ar,
                    "score": score,
                    "plays": plays,
                    "play_timestamp": play_time,
                    "record_timestamp": record_time,
                },
            )

        # Grab any new rivals added during this play session
        rivalnode = request.child("pdata/rival")
        if rivalnode:
            for child in rivalnode.children:
                if child.name != "r":
                    continue

                extid = child.child_value("id")
                other_userid = self.data.remote.user.from_extid(
                    self.game, self.version, extid
                )
                if other_userid is None:
                    continue

                self.data.local.user.put_link(
                    self.game,
                    self.version,
                    userid,
                    "rival",
                    other_userid,
                    {},
                )

        # Grab any new records set during this play session
        songplays = request.child("pdata/stglog")
        if songplays:
            for child in songplays.children:
                if child.name != "log":
                    continue

                songid = child.child_value("mid")
                chart = child.child_value("ng")
                clear_type = child.child_value("ct")
                if songid == 0 and chart == 0 and clear_type == -1:
                    # Dummy song save during profile create
                    continue

                points = child.child_value("sc")
                achievement_rate = child.child_value("ar")
                param = child.child_value("param")
                miss_count = child.child_value("jt_ms")
                k_flag = child.child_value("k_flag")

                # Param is some random bits along with the combo type
                combo_type = param & 0x3
                param = param ^ combo_type

                clear_type = self._game_to_db_clear_type(clear_type)
                combo_type = self._game_to_db_combo_type(combo_type, miss_count)
                self.update_score(
                    userid,
                    songid,
                    chart,
                    points,
                    achievement_rate,
                    clear_type,
                    combo_type,
                    miss_count,
                    param=param,
                    kflag=k_flag,
                )

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

        return newprofile