# vim: set fileencoding=utf-8
import base64
from typing import Any, Dict, List, Optional, Tuple
from typing_extensions import Final

from bemani.backend.ess import EventLogHandler
from bemani.backend.ddr.base import DDRBase
from bemani.backend.ddr.ddr2014 import DDR2014
from bemani.common import Profile, ValidatedDict, VersionConstants, CardCipher, Time, ID, intish
from bemani.data import Data, Achievement, Machine, Score, UserID
from bemani.protocol import Node


class DDRAce(
    DDRBase,
    EventLogHandler,
):

    name: str = 'DanceDanceRevolution A'
    version: int = VersionConstants.DDR_ACE

    GAME_STYLE_SINGLE: Final[int] = 0
    GAME_STYLE_DOUBLE: Final[int] = 1
    GAME_STYLE_VERSUS: Final[int] = 2

    GAME_RIVAL_TYPE_RIVAL3: Final[int] = 32
    GAME_RIVAL_TYPE_RIVAL2: Final[int] = 16
    GAME_RIVAL_TYPE_RIVAL1: Final[int] = 8
    GAME_RIVAL_TYPE_WORLD: Final[int] = 4
    GAME_RIVAL_TYPE_AREA: Final[int] = 2
    GAME_RIVAL_TYPE_MACHINE: Final[int] = 1

    GAME_CHART_SINGLE_BEGINNER: Final[int] = 0
    GAME_CHART_SINGLE_BASIC: Final[int] = 1
    GAME_CHART_SINGLE_DIFFICULT: Final[int] = 2
    GAME_CHART_SINGLE_EXPERT: Final[int] = 3
    GAME_CHART_SINGLE_CHALLENGE: Final[int] = 4
    GAME_CHART_DOUBLE_BASIC: Final[int] = 5
    GAME_CHART_DOUBLE_DIFFICULT: Final[int] = 6
    GAME_CHART_DOUBLE_EXPERT: Final[int] = 7
    GAME_CHART_DOUBLE_CHALLENGE: Final[int] = 8

    GAME_HALO_NONE: Final[int] = 6
    GAME_HALO_GOOD_COMBO: Final[int] = 7
    GAME_HALO_GREAT_COMBO: Final[int] = 8
    GAME_HALO_PERFECT_COMBO: Final[int] = 9
    GAME_HALO_MARVELOUS_COMBO: Final[int] = 10

    GAME_RANK_E: Final[int] = 15
    GAME_RANK_D: Final[int] = 14
    GAME_RANK_D_PLUS: Final[int] = 13
    GAME_RANK_C_MINUS: Final[int] = 12
    GAME_RANK_C: Final[int] = 11
    GAME_RANK_C_PLUS: Final[int] = 10
    GAME_RANK_B_MINUS: Final[int] = 9
    GAME_RANK_B: Final[int] = 8
    GAME_RANK_B_PLUS: Final[int] = 7
    GAME_RANK_A_MINUS: Final[int] = 6
    GAME_RANK_A: Final[int] = 5
    GAME_RANK_A_PLUS: Final[int] = 4
    GAME_RANK_AA_MINUS: Final[int] = 3
    GAME_RANK_AA: Final[int] = 2
    GAME_RANK_AA_PLUS: Final[int] = 1
    GAME_RANK_AAA: Final[int] = 0

    GAME_MAX_SONGS: Final[int] = 1024

    GAME_COMMON_AREA_OFFSET: Final[int] = 1
    GAME_COMMON_WEIGHT_DISPLAY_OFFSET: Final[int] = 3
    GAME_COMMON_CHARACTER_OFFSET: Final[int] = 4
    GAME_COMMON_EXTRA_CHARGE_OFFSET: Final[int] = 5
    GAME_COMMON_TOTAL_PLAYS_OFFSET: Final[int] = 9
    GAME_COMMON_SINGLE_PLAYS_OFFSET: Final[int] = 11
    GAME_COMMON_DOUBLE_PLAYS_OFFSET: Final[int] = 12
    GAME_COMMON_WEIGHT_OFFSET: Final[int] = 17
    GAME_COMMON_NAME_OFFSET: Final[int] = 25
    GAME_COMMON_SEQ_OFFSET: Final[int] = 26

    GAME_OPTION_SPEED_OFFSET: Final[int] = 1
    GAME_OPTION_BOOST_OFFSET: Final[int] = 2
    GAME_OPTION_APPEARANCE_OFFSET: Final[int] = 3
    GAME_OPTION_TURN_OFFSET: Final[int] = 4
    GAME_OPTION_STEP_ZONE_OFFSET: Final[int] = 5
    GAME_OPTION_SCROLL_OFFSET: Final[int] = 6
    GAME_OPTION_ARROW_COLOR_OFFSET: Final[int] = 7
    GAME_OPTION_CUT_OFFSET: Final[int] = 8
    GAME_OPTION_FREEZE_OFFSET: Final[int] = 9
    GAME_OPTION_JUMPS_OFFSET: Final[int] = 10
    GAME_OPTION_ARROW_SKIN_OFFSET: Final[int] = 11
    GAME_OPTION_FILTER_OFFSET: Final[int] = 12
    GAME_OPTION_GUIDELINE_OFFSET: Final[int] = 13
    GAME_OPTION_GAUGE_OFFSET: Final[int] = 14
    GAME_OPTION_COMBO_POSITION_OFFSET: Final[int] = 15
    GAME_OPTION_FAST_SLOW_OFFSET: Final[int] = 16

    GAME_LAST_CALORIES_OFFSET: Final[int] = 10

    GAME_RIVAL_SLOT_1_ACTIVE_OFFSET: Final[int] = 1
    GAME_RIVAL_SLOT_2_ACTIVE_OFFSET: Final[int] = 2
    GAME_RIVAL_SLOT_3_ACTIVE_OFFSET: Final[int] = 3
    GAME_RIVAL_SLOT_1_DDRCODE_OFFSET: Final[int] = 9
    GAME_RIVAL_SLOT_2_DDRCODE_OFFSET: Final[int] = 10
    GAME_RIVAL_SLOT_3_DDRCODE_OFFSET: Final[int] = 11

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

    @classmethod
    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
        # DDR Ace has a weird bug where it sends a profile save for a blank
        # profile before reading it back when creating a new profile. If there
        # is no profile on read-back, it errors out, and it also uses the name
        # and area ID as the takeover/succession data if the user had previous
        # data on an old game. However, if for some reason the user cancels out
        # of the name entry, loses power or disconnects from the network at the
        # right time, then the profile exists in a broken state forever until they
        # edit it on the front-end. As a work-around to this, we remember the last
        # time each profile was written to, and we look up profiles that are older
        # than a few minutes (the maximum possible time for DDR Ace to write back
        # a new profile after creating a blank one) and have blank names and delete
        # them in order to keep the profiles on the network in sane order. This
        # should normally never delete any profiles.
        profiles = data.local.user.get_all_profiles(cls.game, cls.version)
        several_minutes_ago = Time.now() - (Time.SECONDS_IN_MINUTE * 5)
        events = []

        for userid, profile in profiles:
            if profile.get_str('name') == "" and profile.get_int('write_time') < several_minutes_ago:
                data.local.user.delete_profile(cls.game, cls.version, userid)
                events.append((
                    'ddr_profile_purge',
                    {
                        'userid': userid,
                    },
                ))

        return events

    @property
    def supports_paseli(self) -> bool:
        if self.model.dest != 'J':
            # DDR Ace in USA mode doesn't support PASELI properly.
            # When in Asia mode it shows PASELI but won't let you select it.
            return False
        else:
            # All other modes should work with PASELI.
            return True

    def game_to_db_rank(self, game_rank: int) -> int:
        return {
            self.GAME_RANK_AAA: self.RANK_AAA,
            self.GAME_RANK_AA_PLUS: self.RANK_AA_PLUS,
            self.GAME_RANK_AA: self.RANK_AA,
            self.GAME_RANK_AA_MINUS: self.RANK_AA_MINUS,
            self.GAME_RANK_A_PLUS: self.RANK_A_PLUS,
            self.GAME_RANK_A: self.RANK_A,
            self.GAME_RANK_A_MINUS: self.RANK_A_MINUS,
            self.GAME_RANK_B_PLUS: self.RANK_B_PLUS,
            self.GAME_RANK_B: self.RANK_B,
            self.GAME_RANK_B_MINUS: self.RANK_B_MINUS,
            self.GAME_RANK_C_PLUS: self.RANK_C_PLUS,
            self.GAME_RANK_C: self.RANK_C,
            self.GAME_RANK_C_MINUS: self.RANK_C_MINUS,
            self.GAME_RANK_D_PLUS: self.RANK_D_PLUS,
            self.GAME_RANK_D: self.RANK_D,
            self.GAME_RANK_E: self.RANK_E,
        }[game_rank]

    def db_to_game_rank(self, db_rank: int) -> int:
        return {
            self.RANK_AAA: self.GAME_RANK_AAA,
            self.RANK_AA_PLUS: self.GAME_RANK_AA_PLUS,
            self.RANK_AA: self.GAME_RANK_AA,
            self.RANK_AA_MINUS: self.GAME_RANK_AA_MINUS,
            self.RANK_A_PLUS: self.GAME_RANK_A_PLUS,
            self.RANK_A: self.GAME_RANK_A,
            self.RANK_A_MINUS: self.GAME_RANK_A_MINUS,
            self.RANK_B_PLUS: self.GAME_RANK_B_PLUS,
            self.RANK_B: self.GAME_RANK_B,
            self.RANK_B_MINUS: self.GAME_RANK_B_MINUS,
            self.RANK_C_PLUS: self.GAME_RANK_C_PLUS,
            self.RANK_C: self.GAME_RANK_C,
            self.RANK_C_MINUS: self.GAME_RANK_C_MINUS,
            self.RANK_D_PLUS: self.GAME_RANK_D_PLUS,
            self.RANK_D: self.GAME_RANK_D,
            self.RANK_E: self.GAME_RANK_E,
        }[db_rank]

    def game_to_db_chart(self, game_chart: int) -> int:
        return {
            self.GAME_CHART_SINGLE_BEGINNER: self.CHART_SINGLE_BEGINNER,
            self.GAME_CHART_SINGLE_BASIC: self.CHART_SINGLE_BASIC,
            self.GAME_CHART_SINGLE_DIFFICULT: self.CHART_SINGLE_DIFFICULT,
            self.GAME_CHART_SINGLE_EXPERT: self.CHART_SINGLE_EXPERT,
            self.GAME_CHART_SINGLE_CHALLENGE: self.CHART_SINGLE_CHALLENGE,
            self.GAME_CHART_DOUBLE_BASIC: self.CHART_DOUBLE_BASIC,
            self.GAME_CHART_DOUBLE_DIFFICULT: self.CHART_DOUBLE_DIFFICULT,
            self.GAME_CHART_DOUBLE_EXPERT: self.CHART_DOUBLE_EXPERT,
            self.GAME_CHART_DOUBLE_CHALLENGE: self.CHART_DOUBLE_CHALLENGE,
        }[game_chart]

    def db_to_game_chart(self, db_chart: int) -> int:
        return {
            self.CHART_SINGLE_BEGINNER: self.GAME_CHART_SINGLE_BEGINNER,
            self.CHART_SINGLE_BASIC: self.GAME_CHART_SINGLE_BASIC,
            self.CHART_SINGLE_DIFFICULT: self.GAME_CHART_SINGLE_DIFFICULT,
            self.CHART_SINGLE_EXPERT: self.GAME_CHART_SINGLE_EXPERT,
            self.CHART_SINGLE_CHALLENGE: self.GAME_CHART_SINGLE_CHALLENGE,
            self.CHART_DOUBLE_BASIC: self.GAME_CHART_DOUBLE_BASIC,
            self.CHART_DOUBLE_DIFFICULT: self.GAME_CHART_DOUBLE_DIFFICULT,
            self.CHART_DOUBLE_EXPERT: self.GAME_CHART_DOUBLE_EXPERT,
            self.CHART_DOUBLE_CHALLENGE: self.GAME_CHART_DOUBLE_CHALLENGE,
        }[db_chart]

    def game_to_db_halo(self, game_halo: int) -> int:
        if game_halo == self.GAME_HALO_MARVELOUS_COMBO:
            return self.HALO_MARVELOUS_FULL_COMBO
        elif game_halo == self.GAME_HALO_PERFECT_COMBO:
            return self.HALO_PERFECT_FULL_COMBO
        elif game_halo == self.GAME_HALO_GREAT_COMBO:
            return self.HALO_GREAT_FULL_COMBO
        elif game_halo == self.GAME_HALO_GOOD_COMBO:
            return self.HALO_GOOD_FULL_COMBO
        else:
            return self.HALO_NONE

    def db_to_game_halo(self, db_halo: int) -> int:
        if db_halo == self.HALO_MARVELOUS_FULL_COMBO:
            return self.GAME_HALO_MARVELOUS_COMBO
        elif db_halo == self.HALO_PERFECT_FULL_COMBO:
            return self.GAME_HALO_PERFECT_COMBO
        elif db_halo == self.HALO_GREAT_FULL_COMBO:
            return self.GAME_HALO_GREAT_COMBO
        elif db_halo == self.HALO_GOOD_FULL_COMBO:
            return self.GAME_HALO_GOOD_COMBO
        else:
            return self.GAME_HALO_NONE

    def handle_tax_get_phase_request(self, request: Node) -> Node:
        tax = Node.void('tax')
        tax.add_child(Node.s32('phase', 0))
        return tax

    def __handle_userload(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
        has_profile: bool = False
        achievements: List[Achievement] = []
        scores: List[Score] = []

        if userid is not None:
            has_profile = self.has_profile(userid)
            achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
            scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)

        # Place scores into an arrangement for easier distribution to Ace.
        scores_by_mcode: Dict[int, List[Optional[Score]]] = {}
        for score in scores:
            if score.id not in scores_by_mcode:
                scores_by_mcode[score.id] = [None] * 9

            scores_by_mcode[score.id][self.db_to_game_chart(score.chart)] = score

        # First, set new flag
        response.add_child(Node.bool('is_new', not has_profile))

        # Now, return the scores to Ace
        for mcode in scores_by_mcode:
            music = Node.void('music')
            response.add_child(music)
            music.add_child(Node.u32('mcode', mcode))

            scores_that_matter = scores_by_mcode[mcode]
            while scores_that_matter[-1] is None:
                scores_that_matter = scores_that_matter[:-1]

            for score in scores_that_matter:
                note = Node.void('note')
                music.add_child(note)

                if score is None:
                    note.add_child(Node.u16('count', 0))
                    note.add_child(Node.u8('rank', 0))
                    note.add_child(Node.u8('clearkind', 0))
                    note.add_child(Node.s32('score', 0))
                    note.add_child(Node.s32('ghostid', 0))
                else:
                    note.add_child(Node.u16('count', score.plays))
                    note.add_child(Node.u8('rank', self.db_to_game_rank(score.data.get_int('rank'))))
                    note.add_child(Node.u8('clearkind', self.db_to_game_halo(score.data.get_int('halo'))))
                    note.add_child(Node.s32('score', score.points))
                    note.add_child(Node.s32('ghostid', score.key))

        # Active event settings
        activeevents = [
            1,
            3,
            5,
            9,
            10,
            11,
            12,
            13,
            15,
            16,
            17,
            18,
            19,
            20,
            21,
            22,
            23,
            24,
            25,
            26,
            27,
            28,
            29,
            30,
            31,
            32,
            33,
            34,
            35,
            36,
            37,
            38,
            39,
            40,
            41,
            42,
        ]

        # Event reward settings
        rewards = {
            '30': {
                999: 5,
            }
        }

        # Now handle event progress and activation.
        events = {ach.id: ach.data for ach in achievements if ach.type == '9999'}
        progress = [ach for ach in achievements if ach.type != '9999']

        # Make sure we always send a babylon's adventure save event or the game won't send progress
        babylon_included = False
        for evtprogress in progress:
            if evtprogress.id == 999 and evtprogress.type == '30':
                babylon_included = True
                break

        if not babylon_included:
            progress.append(Achievement(
                999,
                '30',
                None,
                {
                    'completed': False,
                    'progress': 0,
                },
            ))

        for event in activeevents:
            # Get completion data
            playerstats = events.get(event, ValidatedDict({'completed': False}))

            # Return the data
            eventdata = Node.void('eventdata')
            response.add_child(eventdata)
            eventdata.add_child(Node.u32('eventid', event))
            eventdata.add_child(Node.s32('eventtype', 9999))
            eventdata.add_child(Node.u32('eventno', 0))
            eventdata.add_child(Node.s64('condition', 0))
            eventdata.add_child(Node.u32('reward', 0))
            eventdata.add_child(Node.s32('comptime', 1 if playerstats.get_bool('completed') else 0))
            eventdata.add_child(Node.s64('savedata', 0))

        for evtprogress in progress:
            # Babylon's adventure progres and anything else the game sends
            eventdata = Node.void('eventdata')
            response.add_child(eventdata)
            eventdata.add_child(Node.u32('eventid', evtprogress.id))
            eventdata.add_child(Node.s32('eventtype', int(evtprogress.type)))
            eventdata.add_child(Node.u32('eventno', 0))
            eventdata.add_child(Node.s64('condition', 0))
            eventdata.add_child(Node.u32('reward', rewards.get(evtprogress.type, {}).get(evtprogress.id)))
            eventdata.add_child(Node.s32('comptime', 1 if evtprogress.data.get_bool('completed') else 0))
            eventdata.add_child(Node.s64('savedata', evtprogress.data.get_int('progress')))

    def __handle_usersave(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
        if userid is None:
            # the game sends us empty user ID strings when a guest is playing.
            # Return early so it doesn't wait a minute and a half to show the
            # results screen.
            return

        if requestdata.child_value('isgameover'):
            style = int(requestdata.child_value('playstyle'))
            is_dp = style == self.GAME_STYLE_DOUBLE

            # We don't save anything for gameover requests, since we
            # already saved scores on individual ones. So, just use this
            # as a spot to bump play counts and such
            play_stats = self.get_play_statistics(userid)
            if is_dp:
                play_stats.increment_int('double_plays')
            else:
                play_stats.increment_int('single_plays')
            self.update_play_statistics(userid, play_stats)

            # Now is a good time to check if we have workout mode enabled,
            # and if so, store the calories earned for this set.
            profile = self.get_profile(userid)
            enabled = profile.get_bool('workout_mode')
            weight = profile.get_int('weight')

            if enabled and weight > 0:
                # We enabled weight display, find the calories and save them
                total = 0
                for child in requestdata.children:
                    if child.name != 'note':
                        continue

                    total = total + (child.child_value('calorie') or 0)

                self.data.local.user.put_time_based_achievement(
                    self.game,
                    self.version,
                    userid,
                    0,
                    'workout',
                    {
                        'calories': total,
                        'weight': weight,
                    },
                )

            # Find any event updates
            for child in requestdata.children:
                if child.name != 'event':
                    continue

                # Skip empty events or events we don't support
                eventid = child.child_value('eventid')
                eventtype = child.child_value('eventtype')
                if eventid == 0 or eventtype == 0:
                    continue

                # Save data to replay to the client later
                completed = child.child_value('comptime') != 0
                progress = child.child_value('savedata')

                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    eventid,
                    str(eventtype),
                    {
                        'completed': completed,
                        'progress': progress,
                    },
                )

            return

        # Find the highest stagenum played
        score = None
        stagenum = 0
        for child in requestdata.children:
            if child.name != 'note':
                continue

            if child.child_value('stagenum') > stagenum:
                score = child
                stagenum = child.child_value('stagenum')

        if score is None:
            raise Exception('Couldn\'t find newest score to save!')

        songid = score.child_value('mcode')
        chart = self.game_to_db_chart(score.child_value('notetype'))
        rank = self.game_to_db_rank(score.child_value('rank'))
        halo = self.game_to_db_halo(score.child_value('clearkind'))
        points = score.child_value('score')
        combo = score.child_value('maxcombo')
        ghost = score.child_value('ghost')
        self.update_score(
            userid,
            songid,
            chart,
            points,
            rank,
            halo,
            combo,
            ghost=ghost,
        )

    def __handle_rivalload(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
        data = Node.void('data')
        response.add_child(data)
        data.add_child(Node.s32('recordtype', requestdata.child_value('loadflag')))

        thismachine = self.data.local.machine.get_machine(self.config.machine.pcbid)
        machines_by_id: Dict[int, Optional[Machine]] = {thismachine.id: thismachine}

        loadkind = requestdata.child_value('loadflag')
        profiles_by_userid: Dict[UserID, Profile] = {}

        def get_machine(lid: int) -> Optional[Machine]:
            if lid not in machines_by_id:
                pcbid = self.data.local.machine.from_machine_id(lid)
                if pcbid is None:
                    machines_by_id[lid] = None
                    return None

                machine = self.data.local.machine.get_machine(pcbid)
                if machine is None:
                    machines_by_id[lid] = None
                    return None

                machines_by_id[lid] = machine
            return machines_by_id[lid]

        if loadkind == self.GAME_RIVAL_TYPE_WORLD:
            # Just load all scores for this network
            scores = self.data.remote.music.get_all_records(self.game, self.music_version)
        elif loadkind == self.GAME_RIVAL_TYPE_AREA:
            if thismachine.arcade is not None:
                match_arcade = thismachine.arcade
                match_machine = None
            else:
                match_arcade = None
                match_machine = thismachine.id

            # Load up all scores by any user registered on a machine in the same arcade
            profiles = self.data.local.user.get_all_profiles(self.game, self.version)
            userids: List[UserID] = []
            for userid, profiledata in profiles:
                profiles_by_userid[userid] = profiledata

                # If we have an arcade to match, see if this user's location matches the arcade.
                # If we don't, just match lid directly
                if match_arcade is not None:
                    theirmachine = get_machine(profiledata.get_int('lid'))
                    if theirmachine is not None and theirmachine.arcade == match_arcade:
                        userids.append(userid)
                elif match_machine is not None:
                    if profiledata.get_int('lid') == match_machine:
                        userids.append(userid)

            # Load all scores for users in the area
            scores = self.data.local.music.get_all_records(self.game, self.music_version, userlist=userids)
        elif loadkind == self.GAME_RIVAL_TYPE_MACHINE:
            # Load up all scores and filter them by those earned at this location
            scores = self.data.local.music.get_all_records(self.game, self.music_version, locationlist=[thismachine.id])
        elif loadkind in [
            self.GAME_RIVAL_TYPE_RIVAL1,
            self.GAME_RIVAL_TYPE_RIVAL2,
            self.GAME_RIVAL_TYPE_RIVAL3,
        ]:
            # Load up this user's highscores, format the way the below code expects it
            extid = requestdata.child_value('ddrcode')
            otherid = self.data.remote.user.from_extid(self.game, self.version, extid)
            userscores = self.data.remote.music.get_scores(self.game, self.music_version, otherid)
            scores = [(otherid, score) for score in userscores]
        else:
            # Nothing here
            scores = []

        missing_users = [userid for (userid, _) in scores if userid not in profiles_by_userid]
        for (userid, profile) in self.get_any_profiles(missing_users):
            profiles_by_userid[userid] = profile

        for userid, score in scores:
            if profiles_by_userid.get(userid) is None:
                raise Exception(f'Logic error, couldn\'t find any profile for {userid}')
            profiledata = profiles_by_userid[userid]

            record = Node.void('record')
            data.add_child(record)
            record.add_child(Node.u32('mcode', score.id))
            record.add_child(Node.u8('notetype', self.db_to_game_chart(score.chart)))
            record.add_child(Node.u8('rank', self.db_to_game_rank(score.data.get_int('rank'))))
            record.add_child(Node.u8('clearkind', self.db_to_game_halo(score.data.get_int('halo'))))
            record.add_child(Node.u8('flagdata', 0))
            record.add_child(Node.string('name', profiledata.get_str('name')))
            record.add_child(Node.s32('area', profiledata.get_int('area', 58)))
            record.add_child(Node.s32('code', profiledata.extid))
            record.add_child(Node.s32('score', score.points))
            record.add_child(Node.s32('ghostid', score.key))

    def __handle_usernew(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
        if userid is None:
            raise Exception('Expecting valid UserID to create new profile!')

        machine = self.data.local.machine.get_machine(self.config.machine.pcbid)
        profile = Profile(
            self.game,
            self.version,
            "",
            0,
            {
                'lid': machine.id,
            },
        )
        self.put_profile(userid, profile)

        response.add_child(Node.string('seq', ID.format_extid(profile.extid)))
        response.add_child(Node.s32('code', profile.extid))
        response.add_child(Node.string('shoparea', ''))

    def __handle_inheritance(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
        if userid is not None:
            previous_version = self.previous_version()
            profile = previous_version.get_profile(userid)
        else:
            profile = None

        response.add_child(Node.s32('InheritanceStatus', 1 if profile is not None else 0))

    def __handle_ghostload(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
        ghostid = requestdata.child_value('ghostid')
        ghost = self.data.local.music.get_score_by_key(self.game, self.music_version, ghostid)
        if ghost is None:
            return

        userid, score = ghost
        profile = self.get_profile(userid)
        if profile is None:
            return

        if 'ghost' not in score.data:
            return

        ghostdata = Node.void('ghostdata')
        response.add_child(ghostdata)
        ghostdata.add_child(Node.s32('code', profile.extid))
        ghostdata.add_child(Node.u32('mcode', score.id))
        ghostdata.add_child(Node.u8('notetype', self.db_to_game_chart(score.chart)))
        ghostdata.add_child(Node.s32('ghostsize', len(score.data['ghost'])))
        ghostdata.add_child(Node.string('ghost', score.data['ghost']))

    def handle_playerdata_usergamedata_advanced_request(self, request: Node) -> Optional[Node]:
        playerdata = Node.void('playerdata')

        # DDR Ace decides to be difficult and have a third level of packet switching
        mode = request.child_value('data/mode')
        refid = request.child_value('data/refid')
        extid = request.child_value('data/ddrcode')

        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is None:
            # Possibly look up by extid instead
            userid = self.data.remote.user.from_extid(self.game, self.version, extid)

        if mode == 'userload':
            self.__handle_userload(userid, request.child('data'), playerdata)
        elif mode == 'usersave':
            self.__handle_usersave(userid, request.child('data'), playerdata)
        elif mode == 'rivalload':
            self.__handle_rivalload(userid, request.child('data'), playerdata)
        elif mode == 'usernew':
            self.__handle_usernew(userid, request.child('data'), playerdata)
        elif mode == 'inheritance':
            self.__handle_inheritance(userid, request.child('data'), playerdata)
        elif mode == 'ghostload':
            self.__handle_ghostload(userid, request.child('data'), playerdata)
        else:
            # We don't support this
            return None

        playerdata.add_child(Node.s32('result', 0))
        return playerdata

    def handle_playerdata_usergamedata_send_request(self, request: Node) -> Node:
        playerdata = Node.void('playerdata')
        refid = request.child_value('data/refid')

        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is not None:
            profile = self.get_profile(userid) or Profile(self.game, self.version, refid, 0)
            usergamedata = profile.get_dict('usergamedata')

            for record in request.child('data/record').children:
                if record.name != 'd':
                    continue

                strdata = base64.b64decode(record.value)
                bindata = base64.b64decode(record.child_value('bin1'))

                # Grab and format the profile objects
                strdatalist = strdata.split(b',')
                profiletype = strdatalist[1].decode('utf-8')
                strdatalist = strdatalist[2:]

                # Extract relevant bits for frontend/API
                if profiletype == 'COMMON':
                    profile.replace_str('name', strdatalist[self.GAME_COMMON_NAME_OFFSET].decode('ascii'))
                    profile.replace_int('area', intish(strdatalist[self.GAME_COMMON_AREA_OFFSET].decode('ascii'), 16))
                    profile.replace_bool('workout_mode', int(strdatalist[self.GAME_COMMON_WEIGHT_DISPLAY_OFFSET].decode('ascii'), 16) != 0)
                    profile.replace_int('weight', int(float(strdatalist[self.GAME_COMMON_WEIGHT_OFFSET].decode('ascii')) * 10))
                    profile.replace_int('character', int(strdatalist[self.GAME_COMMON_CHARACTER_OFFSET].decode('ascii'), 16))
                if profiletype == 'OPTION':
                    profile.replace_int('combo', int(strdatalist[self.GAME_OPTION_COMBO_POSITION_OFFSET].decode('ascii'), 16))
                    profile.replace_int('early_late', int(strdatalist[self.GAME_OPTION_FAST_SLOW_OFFSET].decode('ascii'), 16))
                    profile.replace_int('arrowskin', int(strdatalist[self.GAME_OPTION_ARROW_SKIN_OFFSET].decode('ascii'), 16))
                    profile.replace_int('guidelines', int(strdatalist[self.GAME_OPTION_GUIDELINE_OFFSET].decode('ascii'), 16))
                    profile.replace_int('filter', int(strdatalist[self.GAME_OPTION_FILTER_OFFSET].decode('ascii'), 16))

                usergamedata[profiletype] = {
                    'strdata': b','.join(strdatalist),
                    'bindata': bindata,
                }

            profile.replace_dict('usergamedata', usergamedata)
            profile.replace_int('write_time', Time.now())
            self.put_profile(userid, profile)

        playerdata.add_child(Node.s32('result', 0))
        return playerdata

    def handle_playerdata_usergamedata_recv_request(self, request: Node) -> Node:
        playerdata = Node.void('playerdata')

        player = Node.void('player')
        playerdata.add_child(player)

        refid = request.child_value('data/refid')
        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is not None:
            profile = self.get_profile(userid)
            links = self.data.local.user.get_links(self.game, self.version, userid)
            records = 0

            record = Node.void('record')
            player.add_child(record)

            def acehex(val: int) -> str:
                return hex(val)[2:]

            if profile is None:
                # Just return a default empty node
                record.add_child(Node.string('d', '<NODATA>'))
                records = 1
            else:
                # Figure out what profiles are being requested
                profiletypes = request.child_value('data/recv_csv').split(',')[::2]
                usergamedata = profile.get_dict('usergamedata')
                for ptype in profiletypes:
                    if ptype in usergamedata:
                        records = records + 1

                        if ptype == "COMMON":
                            # Return basic profile options
                            name = profile.get_str('name')
                            area = profile.get_int('area', self.get_machine_region())
                            if name == "":
                                # This is a bogus profile created by the first login, substitute the
                                # previous version values so that profile succession works.
                                previous_version = self.previous_version()
                                old_profile = previous_version.get_profile(userid)
                                if old_profile is not None:
                                    name = old_profile.get_str('name')
                                    area = old_profile.get_int('area', self.get_machine_region())
                                else:
                                    area = self.get_machine_region()

                            common = usergamedata[ptype]['strdata'].split(b',')
                            common[self.GAME_COMMON_NAME_OFFSET] = name.encode('ascii')
                            common[self.GAME_COMMON_AREA_OFFSET] = acehex(area).encode('ascii')
                            common[self.GAME_COMMON_WEIGHT_DISPLAY_OFFSET] = b'1' if profile.get_bool('workout_mode') else b'0'
                            common[self.GAME_COMMON_WEIGHT_OFFSET] = str(float(profile.get_int('weight')) / 10.0).encode('ascii')
                            common[self.GAME_COMMON_CHARACTER_OFFSET] = acehex(profile.get_int('character')).encode('ascii')
                            usergamedata[ptype]['strdata'] = b','.join(common)
                        if ptype == "OPTION":
                            # Return user settings for frontend
                            option = usergamedata[ptype]['strdata'].split(b',')
                            option[self.GAME_OPTION_FAST_SLOW_OFFSET] = acehex(profile.get_int('early_late')).encode('ascii')
                            option[self.GAME_OPTION_COMBO_POSITION_OFFSET] = acehex(profile.get_int('combo')).encode('ascii')
                            option[self.GAME_OPTION_ARROW_SKIN_OFFSET] = acehex(profile.get_int('arrowskin')).encode('ascii')
                            option[self.GAME_OPTION_GUIDELINE_OFFSET] = acehex(profile.get_int('guidelines')).encode('ascii')
                            option[self.GAME_OPTION_FILTER_OFFSET] = acehex(profile.get_int('filter')).encode('ascii')
                            usergamedata[ptype]['strdata'] = b','.join(option)
                        if ptype == "LAST":
                            # Return the number of calories expended in the last day
                            workouts = self.data.local.user.get_time_based_achievements(
                                self.game,
                                self.version,
                                userid,
                                achievementtype='workout',
                                since=Time.now() - Time.SECONDS_IN_DAY,
                            )
                            total = sum([w.data.get_int('calories') for w in workouts])

                            last = usergamedata[ptype]['strdata'].split(b',')
                            last[self.GAME_LAST_CALORIES_OFFSET] = acehex(total).encode('ascii')
                            usergamedata[ptype]['strdata'] = b','.join(last)
                        if ptype == "RIVAL":
                            # Fill in the DDR code and active status of the three active
                            # rivals.
                            rival = usergamedata[ptype]['strdata'].split(b',')
                            lastdict = profile.get_dict('last')

                            friends: Dict[int, Optional[Profile]] = {}
                            for link in links:
                                if link.type[:7] != 'friend_':
                                    continue

                                pos = int(link.type[7:])
                                friends[pos] = self.get_profile(link.other_userid)

                            for rivalno in [1, 2, 3]:
                                activeslot = {
                                    1: self.GAME_RIVAL_SLOT_1_ACTIVE_OFFSET,
                                    2: self.GAME_RIVAL_SLOT_2_ACTIVE_OFFSET,
                                    3: self.GAME_RIVAL_SLOT_3_ACTIVE_OFFSET,
                                }[rivalno]

                                whichfriend = lastdict.get_int(f'rival{rivalno}') - 1
                                if whichfriend < 0:
                                    # This rival isn't active
                                    rival[activeslot] = b'0'
                                    continue

                                friendprofile = friends.get(whichfriend)
                                if friendprofile is None:
                                    # This rival doesn't exist
                                    rival[activeslot] = b'0'
                                    continue

                                ddrcodeslot = {
                                    1: self.GAME_RIVAL_SLOT_1_DDRCODE_OFFSET,
                                    2: self.GAME_RIVAL_SLOT_2_DDRCODE_OFFSET,
                                    3: self.GAME_RIVAL_SLOT_3_DDRCODE_OFFSET,
                                }[rivalno]

                                rival[activeslot] = acehex(rivalno).encode('ascii')
                                rival[ddrcodeslot] = acehex(friendprofile.extid).encode('ascii')

                            usergamedata[ptype]['strdata'] = b','.join(rival)

                        dnode = Node.string('d', base64.b64encode(usergamedata[ptype]['strdata']).decode('ascii'))
                        dnode.add_child(Node.string('bin1', base64.b64encode(usergamedata[ptype]['bindata']).decode('ascii')))
                        record.add_child(dnode)

            player.add_child(Node.u32('record_num', records))

        playerdata.add_child(Node.s32('result', 0))
        return playerdata

    def handle_system_convcardnumber_request(self, request: Node) -> Node:
        cardid = request.child_value('data/card_id')
        cardnumber = CardCipher.encode(cardid)

        system = Node.void('system')
        data = Node.void('data')
        system.add_child(data)

        system.add_child(Node.s32('result', 0))
        data.add_child(Node.string('card_number', cardnumber))
        return system