bemaniutils/bemani/client/iidx/cannonballers.py

import random
import time
from typing import Any, Dict, Optional, Tuple

from bemani.client.base import BaseClient
from bemani.protocol import Node


class IIDXCannonBallersClient(BaseClient):
    NAME = "TEST"

    def verify_iidx25shop_getname(self, lid: str) -> str:
        call = self.call_node()

        # Construct node
        IIDX25shop = Node.void("IIDX25shop")
        call.add_child(IIDX25shop)
        IIDX25shop.set_attribute("method", "getname")
        IIDX25shop.set_attribute("lid", lid)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/IIDX25shop/@opname")
        self.assert_path(resp, "response/IIDX25shop/@pid")
        self.assert_path(resp, "response/IIDX25shop/@cls_opt")
        self.assert_path(resp, "response/IIDX25shop/@hr")
        self.assert_path(resp, "response/IIDX25shop/@mi")

        return resp.child("IIDX25shop").attribute("opname")

    def verify_iidx25shop_savename(self, lid: str, name: str) -> None:
        call = self.call_node()

        # Construct node
        IIDX25shop = Node.void("IIDX25shop")
        IIDX25shop.set_attribute("lid", lid)
        IIDX25shop.set_attribute("pid", "51")
        IIDX25shop.set_attribute("method", "savename")
        IIDX25shop.set_attribute("cls_opt", "0")
        IIDX25shop.set_attribute("ccode", "US")
        IIDX25shop.set_attribute("opname", name)
        IIDX25shop.set_attribute("rcode", ".")

        call.add_child(IIDX25shop)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/IIDX25shop")

    def verify_iidx25pc_common(self) -> None:
        call = self.call_node()

        # Construct node
        IIDX25pc = Node.void("IIDX25pc")
        call.add_child(IIDX25pc)
        IIDX25pc.set_attribute("method", "common")

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/IIDX25pc/ir/@beat")
        self.assert_path(resp, "response/IIDX25pc/newsong_another/@open")
        self.assert_path(resp, "response/IIDX25pc/boss/@phase")
        self.assert_path(resp, "response/IIDX25pc/event1_phase/@phase")
        self.assert_path(resp, "response/IIDX25pc/extra_boss_event/@phase")
        self.assert_path(resp, "response/IIDX25pc/expert/@phase")
        self.assert_path(resp, "response/IIDX25pc/expert_random_select/@phase")
        self.assert_path(resp, "response/IIDX25pc/common_evnet/@flg")

    def verify_iidx25music_crate(self) -> None:
        call = self.call_node()

        # Construct node
        IIDX25pc = Node.void("IIDX25music")
        call.add_child(IIDX25pc)
        IIDX25pc.set_attribute("method", "crate")

        # Swap with server
        resp = self.exchange("", call)

        self.assert_path(resp, "response/IIDX25music")
        for child in resp.child("IIDX25music").children:
            if child.name != "c":
                raise Exception(f"Invalid node {child} in clear rate response!")
            if len(child.value) != 12:
                raise Exception(f"Invalid node data {child} in clear rate response!")
            for v in child.value:
                if v < 0 or v > 1001:
                    raise Exception(
                        f"Invalid clear percent {child} in clear rate response!"
                    )

    def verify_iidx25shop_getconvention(self, lid: str) -> None:
        call = self.call_node()

        # Construct node
        IIDX25pc = Node.void("IIDX25shop")
        call.add_child(IIDX25pc)
        IIDX25pc.set_attribute("method", "getconvention")
        IIDX25pc.set_attribute("lid", lid)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/IIDX25shop/valid")
        self.assert_path(resp, "response/IIDX25shop/@music_0")
        self.assert_path(resp, "response/IIDX25shop/@music_1")
        self.assert_path(resp, "response/IIDX25shop/@music_2")
        self.assert_path(resp, "response/IIDX25shop/@music_3")

    def verify_iidx25pc_visit(self, extid: int, lid: str) -> None:
        call = self.call_node()

        # Construct node
        IIDX25pc = Node.void("IIDX25pc")
        call.add_child(IIDX25pc)
        IIDX25pc.set_attribute("iidxid", str(extid))
        IIDX25pc.set_attribute("lid", lid)
        IIDX25pc.set_attribute("method", "visit")
        IIDX25pc.set_attribute("pid", "51")

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/IIDX25pc/@aflg")
        self.assert_path(resp, "response/IIDX25pc/@anum")
        self.assert_path(resp, "response/IIDX25pc/@pflg")
        self.assert_path(resp, "response/IIDX25pc/@pnum")
        self.assert_path(resp, "response/IIDX25pc/@sflg")
        self.assert_path(resp, "response/IIDX25pc/@snum")

    def verify_iidx25ranking_getranker(self, lid: str) -> None:
        for clid in [0, 1, 2, 3, 4, 5, 6]:
            call = self.call_node()

            # Construct node
            IIDX25pc = Node.void("IIDX25ranking")
            call.add_child(IIDX25pc)
            IIDX25pc.set_attribute("method", "getranker")
            IIDX25pc.set_attribute("lid", lid)
            IIDX25pc.set_attribute("clid", str(clid))

            # Swap with server
            resp = self.exchange("", call)

            # Verify that response is correct
            self.assert_path(resp, "response/IIDX25ranking")

    def verify_iidx25shop_sentinfo(self, lid: str, shop_name: str) -> None:
        call = self.call_node()

        # Construct node
        IIDX25pc = Node.void("IIDX25shop")
        call.add_child(IIDX25pc)
        IIDX25pc.set_attribute("method", "sentinfo")
        IIDX25pc.set_attribute("lid", lid)
        IIDX25pc.set_attribute("bflg", "1")
        IIDX25pc.set_attribute("bnum", "2")
        IIDX25pc.set_attribute("ioid", "0")
        IIDX25pc.set_attribute("company_code", "")
        IIDX25pc.set_attribute("consumer_code", "")
        IIDX25pc.set_attribute("location_name", shop_name)
        IIDX25pc.set_attribute("tax_phase", "0")

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/IIDX25shop")

    def verify_iidx25pc_get(
        self, ref_id: str, card_id: str, lid: str
    ) -> Dict[str, Any]:
        call = self.call_node()

        # Construct node
        IIDX25pc = Node.void("IIDX25pc")
        call.add_child(IIDX25pc)
        IIDX25pc.set_attribute("rid", ref_id)
        IIDX25pc.set_attribute("did", ref_id)
        IIDX25pc.set_attribute("pid", "51")
        IIDX25pc.set_attribute("lid", lid)
        IIDX25pc.set_attribute("cid", card_id)
        IIDX25pc.set_attribute("method", "get")
        IIDX25pc.set_attribute("ctype", "1")

        # Swap with server
        resp = self.exchange("", call)

        # Verify that the response is correct
        self.assert_path(resp, "response/IIDX25pc/pcdata/@name")
        self.assert_path(resp, "response/IIDX25pc/pcdata/@pid")
        self.assert_path(resp, "response/IIDX25pc/pcdata/@id")
        self.assert_path(resp, "response/IIDX25pc/pcdata/@idstr")
        self.assert_path(resp, "response/IIDX25pc/deller")
        self.assert_path(resp, "response/IIDX25pc/secret/flg1")
        self.assert_path(resp, "response/IIDX25pc/secret/flg2")
        self.assert_path(resp, "response/IIDX25pc/secret/flg3")
        self.assert_path(resp, "response/IIDX25pc/achievements/trophy")
        self.assert_path(resp, "response/IIDX25pc/skin")
        self.assert_path(resp, "response/IIDX25pc/qprodata")
        self.assert_path(resp, "response/IIDX25pc/grade")
        self.assert_path(resp, "response/IIDX25pc/ir_data")
        self.assert_path(resp, "response/IIDX25pc/secret_course_data")
        self.assert_path(resp, "response/IIDX25pc/classic_course_data")
        self.assert_path(resp, "response/IIDX25pc/rlist")
        self.assert_path(resp, "response/IIDX25pc/step")
        self.assert_path(resp, "response/IIDX25pc/favorite/sp_mlist")
        self.assert_path(resp, "response/IIDX25pc/favorite/sp_clist")
        self.assert_path(resp, "response/IIDX25pc/favorite/dp_mlist")
        self.assert_path(resp, "response/IIDX25pc/favorite/dp_clist")
        self.assert_path(resp, "response/IIDX25pc/extra_favorite/sp_mlist")
        self.assert_path(resp, "response/IIDX25pc/extra_favorite/sp_clist")
        self.assert_path(resp, "response/IIDX25pc/extra_favorite/dp_mlist")
        self.assert_path(resp, "response/IIDX25pc/extra_favorite/dp_clist")

        name = resp.child("IIDX25pc/pcdata").attribute("name")
        if name != self.NAME:
            raise Exception(f"Invalid name '{name}' returned for Ref ID '{ref_id}'")

        # Extract and return account data
        ir_data: Dict[int, Dict[int, Dict[str, int]]] = {}
        for child in resp.child("IIDX25pc/ir_data").children:
            if child.name == "e":
                course_id = child.value[0]
                course_chart = child.value[1]
                clear_status = child.value[2]
                pgnum = child.value[3]
                gnum = child.value[4]

                if course_id not in ir_data:
                    ir_data[course_id] = {}
                ir_data[course_id][course_chart] = {
                    "clear_status": clear_status,
                    "pgnum": pgnum,
                    "gnum": gnum,
                }

        secret_course_data: Dict[int, Dict[int, Dict[str, int]]] = {}
        for child in resp.child("IIDX25pc/secret_course_data").children:
            if child.name == "e":
                course_id = child.value[0]
                course_chart = child.value[1]
                clear_status = child.value[2]
                pgnum = child.value[3]
                gnum = child.value[4]

                if course_id not in secret_course_data:
                    secret_course_data[course_id] = {}
                secret_course_data[course_id][course_chart] = {
                    "clear_status": clear_status,
                    "pgnum": pgnum,
                    "gnum": gnum,
                }

        classic_course_data: Dict[int, Dict[int, Dict[str, int]]] = {}  # noqa: E701
        for child in resp.child("IIDX25pc/classic_course_data").children:
            if child.name == "score_data":
                course_id = int(child.attribute("course_id"))
                course_chart = int(child.attribute("play_style"))
                clear_status = int(child.attribute("cflg"))
                pgnum = int(child.attribute("pgnum"))
                gnum = int(child.attribute("gnum"))

                if course_id not in classic_course_data:
                    classic_course_data[course_id] = {}
                classic_course_data[course_id][course_chart] = {
                    "clear_status": clear_status,
                    "pgnum": pgnum,
                    "gnum": gnum,
                }

        expert_point: Dict[int, Dict[str, int]] = {}
        for child in resp.child("IIDX25pc/expert_point").children:
            if child.name == "detail":
                expert_point[int(child.attribute("course_id"))] = {
                    "n_point": int(child.attribute("n_point")),
                    "h_point": int(child.attribute("h_point")),
                    "a_point": int(child.attribute("a_point")),
                }

        return {
            "extid": int(resp.child("IIDX25pc/pcdata").attribute("id")),
            "sp_dan": int(resp.child("IIDX25pc/grade").attribute("sgid")),
            "dp_dan": int(resp.child("IIDX25pc/grade").attribute("dgid")),
            "deller": int(resp.child("IIDX25pc/deller").attribute("deller")),
            "ir_data": ir_data,
            "secret_course_data": secret_course_data,
            "classic_course_data": classic_course_data,
            "expert_point": expert_point,
        }

    def verify_iidx25music_getrank(
        self, extid: int
    ) -> Dict[int, Dict[int, Dict[str, int]]]:
        scores: Dict[int, Dict[int, Dict[str, int]]] = {}
        for cltype in [0, 1]:  # singles, doubles
            call = self.call_node()

            # Construct node
            IIDX25music = Node.void("IIDX25music")
            call.add_child(IIDX25music)
            IIDX25music.set_attribute("method", "getrank")
            IIDX25music.set_attribute("iidxid", str(extid))
            IIDX25music.set_attribute("cltype", str(cltype))

            # Swap with server
            resp = self.exchange("", call)

            self.assert_path(resp, "response/IIDX25music/style")
            if int(resp.child("IIDX25music/style").attribute("type")) != cltype:
                raise Exception("Returned wrong clear type for IIDX25music.getrank!")

            for child in resp.child("IIDX25music").children:
                if child.name == "m":
                    if child.value[0] != -1:
                        raise Exception(
                            "Got non-self score back when requesting only our scores!"
                        )

                    music_id = child.value[1]
                    normal_clear_status = child.value[2]
                    hyper_clear_status = child.value[3]
                    another_clear_status = child.value[4]
                    normal_ex_score = child.value[5]
                    hyper_ex_score = child.value[6]
                    another_ex_score = child.value[7]
                    normal_miss_count = child.value[8]
                    hyper_miss_count = child.value[9]
                    another_miss_count = child.value[10]

                    if cltype == 0:
                        normal = 0
                        hyper = 1
                        another = 2
                    else:
                        normal = 3
                        hyper = 4
                        another = 5

                    if music_id not in scores:
                        scores[music_id] = {}

                    scores[music_id][normal] = {
                        "clear_status": normal_clear_status,
                        "ex_score": normal_ex_score,
                        "miss_count": normal_miss_count,
                    }
                    scores[music_id][hyper] = {
                        "clear_status": hyper_clear_status,
                        "ex_score": hyper_ex_score,
                        "miss_count": hyper_miss_count,
                    }
                    scores[music_id][another] = {
                        "clear_status": another_clear_status,
                        "ex_score": another_ex_score,
                        "miss_count": another_miss_count,
                    }
                elif child.name == "b":
                    music_id = child.value[0]
                    clear_status = child.value[1]

                    scores[music_id][6] = {
                        "clear_status": clear_status,
                        "ex_score": -1,
                        "miss_count": -1,
                    }

        return scores

    def verify_iidx25pc_save(
        self,
        extid: int,
        card: str,
        lid: str,
        expert_point: Optional[Dict[str, int]] = None,
    ) -> None:
        call = self.call_node()

        # Construct node
        IIDX25pc = Node.void("IIDX25pc")
        call.add_child(IIDX25pc)
        IIDX25pc.set_attribute("iidxid", str(extid))
        IIDX25pc.set_attribute("lid", lid)
        IIDX25pc.set_attribute("cid", card)
        IIDX25pc.set_attribute("bookkeep", "0")
        IIDX25pc.set_attribute("cltype", "0")
        IIDX25pc.set_attribute("ctype", "2")
        IIDX25pc.set_attribute("d_achi", "0")
        IIDX25pc.set_attribute("d_auto_scrach", "0")
        IIDX25pc.set_attribute("d_camera_layout", "0")
        IIDX25pc.set_attribute("d_disp_judge", "0")
        IIDX25pc.set_attribute("d_exscore", "0")
        IIDX25pc.set_attribute("d_gauge_disp", "0")
        IIDX25pc.set_attribute("d_gno", "0")
        IIDX25pc.set_attribute("d_graph_score", "0")
        IIDX25pc.set_attribute("d_gtype", "0")
        IIDX25pc.set_attribute("d_hispeed", "1.000000")
        IIDX25pc.set_attribute("d_judge", "0")
        IIDX25pc.set_attribute("d_judgeAdj", "0")
        IIDX25pc.set_attribute("d_lane_brignt", "0")
        IIDX25pc.set_attribute("d_lift", "0")
        IIDX25pc.set_attribute("d_notes", "0.000000")
        IIDX25pc.set_attribute("d_opstyle", "0")
        IIDX25pc.set_attribute("d_pace", "0")
        IIDX25pc.set_attribute("d_sdlen", "0")
        IIDX25pc.set_attribute("d_sdtype", "0")
        IIDX25pc.set_attribute("d_sorttype", "0")
        IIDX25pc.set_attribute("d_timing", "0")
        IIDX25pc.set_attribute("d_tune", "0")
        IIDX25pc.set_attribute("dp_opt", "16384")
        IIDX25pc.set_attribute("dp_opt2", "16384")
        IIDX25pc.set_attribute("gpos", "0")
        IIDX25pc.set_attribute("method", "save")
        IIDX25pc.set_attribute("mode", "0")
        IIDX25pc.set_attribute("pmode", "0")
        IIDX25pc.set_attribute("rtype", "0")
        IIDX25pc.set_attribute("s_achi", "1")
        IIDX25pc.set_attribute("s_auto_scrach", "0")
        IIDX25pc.set_attribute("s_camera_layout", "0")
        IIDX25pc.set_attribute("s_disp_judge", "0")
        IIDX25pc.set_attribute("s_exscore", "0")
        IIDX25pc.set_attribute("s_gauge_disp", "0")
        IIDX25pc.set_attribute("s_gno", "1")
        IIDX25pc.set_attribute("s_graph_score", "0")
        IIDX25pc.set_attribute("s_gtype", "0")
        IIDX25pc.set_attribute("s_hispeed", "2.794393")
        IIDX25pc.set_attribute("s_judge", "0")
        IIDX25pc.set_attribute("s_judgeAdj", "0")
        IIDX25pc.set_attribute("s_lane_brignt", "0")
        IIDX25pc.set_attribute("s_lift", "60")
        IIDX25pc.set_attribute("s_notes", "104.859825")
        IIDX25pc.set_attribute("s_opstyle", "1")
        IIDX25pc.set_attribute("s_pace", "0")
        IIDX25pc.set_attribute("s_sdlen", "227")
        IIDX25pc.set_attribute("s_sdtype", "1")
        IIDX25pc.set_attribute("s_sorttype", "0")
        IIDX25pc.set_attribute("s_timing", "0")
        IIDX25pc.set_attribute("s_tune", "1")
        IIDX25pc.set_attribute("sp_opt", "139264")
        deller = Node.void("deller")
        IIDX25pc.add_child(deller)
        deller.set_attribute("deller", "150")

        if expert_point is not None:
            epnode = Node.void("expert_point")
            epnode.set_attribute("h_point", str(expert_point["h_point"]))
            epnode.set_attribute("course_id", str(expert_point["course_id"]))
            epnode.set_attribute("n_point", str(expert_point["n_point"]))
            epnode.set_attribute("a_point", str(expert_point["a_point"]))
            IIDX25pc.add_child(epnode)

        # Swap with server
        resp = self.exchange("", call)
        self.assert_path(resp, "response/IIDX25pc")

    def verify_iidx25music_reg(
        self, extid: int, lid: str, score: Dict[str, Any]
    ) -> None:
        call = self.call_node()

        # Construct node
        IIDX25music = Node.void("IIDX25music")
        call.add_child(IIDX25music)
        IIDX25music.set_attribute("convid", "-1")
        IIDX25music.set_attribute("iidxid", str(extid))
        IIDX25music.set_attribute("pgnum", str(score["pgnum"]))
        IIDX25music.set_attribute("pid", "51")
        IIDX25music.set_attribute("rankside", "1")
        IIDX25music.set_attribute("cflg", str(score["clear_status"]))
        IIDX25music.set_attribute("method", "reg")
        IIDX25music.set_attribute("gnum", str(score["gnum"]))
        IIDX25music.set_attribute("clid", str(score["chart"]))
        IIDX25music.set_attribute("mnum", str(score["mnum"]))
        IIDX25music.set_attribute("is_death", "0")
        IIDX25music.set_attribute("theory", "0")
        IIDX25music.set_attribute("dj_level", "1")
        IIDX25music.set_attribute("location_id", lid)
        IIDX25music.set_attribute("mid", str(score["id"]))
        IIDX25music.add_child(Node.binary("ghost", bytes([1] * 64)))

        # Swap with server
        resp = self.exchange("", call)
        self.assert_path(resp, "response/IIDX25music/shopdata/@rank")
        self.assert_path(resp, "response/IIDX25music/ranklist/data")

    def verify_iidx25music_appoint(
        self, extid: int, musicid: int, chart: int
    ) -> Tuple[int, bytes]:
        call = self.call_node()

        # Construct node
        IIDX25music = Node.void("IIDX25music")
        call.add_child(IIDX25music)
        IIDX25music.set_attribute("clid", str(chart))
        IIDX25music.set_attribute("method", "appoint")
        IIDX25music.set_attribute("ctype", "0")
        IIDX25music.set_attribute("iidxid", str(extid))
        IIDX25music.set_attribute("subtype", "")
        IIDX25music.set_attribute("mid", str(musicid))

        # Swap with server
        resp = self.exchange("", call)
        self.assert_path(resp, "response/IIDX25music/mydata/@score")

        return (
            int(resp.child("IIDX25music/mydata").attribute("score")),
            resp.child_value("IIDX25music/mydata"),
        )

    def verify_iidx25pc_reg(self, ref_id: str, card_id: str, lid: str) -> int:
        call = self.call_node()

        # Construct node
        IIDX25pc = Node.void("IIDX25pc")
        call.add_child(IIDX25pc)
        IIDX25pc.set_attribute("lid", lid)
        IIDX25pc.set_attribute("pid", "51")
        IIDX25pc.set_attribute("method", "reg")
        IIDX25pc.set_attribute("cid", card_id)
        IIDX25pc.set_attribute("did", ref_id)
        IIDX25pc.set_attribute("rid", ref_id)
        IIDX25pc.set_attribute("name", self.NAME)

        # Swap with server
        resp = self.exchange("", call)

        # Verify nodes that cause crashes if they don't exist
        self.assert_path(resp, "response/IIDX25pc/@id")
        self.assert_path(resp, "response/IIDX25pc/@id_str")

        return int(resp.child("IIDX25pc").attribute("id"))

    def verify_iidx25pc_playstart(self) -> None:
        call = self.call_node()

        # Construct node
        IIDX25pc = Node.void("IIDX25pc")
        IIDX25pc.set_attribute("method", "playstart")
        IIDX25pc.set_attribute("side", "1")
        call.add_child(IIDX25pc)

        # Swap with server
        resp = self.exchange("", call)

        # Verify nodes that cause crashes if they don't exist
        self.assert_path(resp, "response/IIDX25pc")

    def verify_iidx25music_play(self, score: Dict[str, int]) -> None:
        call = self.call_node()

        # Construct node
        IIDX25music = Node.void("IIDX25music")
        IIDX25music.set_attribute("opt", "64")
        IIDX25music.set_attribute("clid", str(score["chart"]))
        IIDX25music.set_attribute("mid", str(score["id"]))
        IIDX25music.set_attribute("gnum", str(score["gnum"]))
        IIDX25music.set_attribute("cflg", str(score["clear_status"]))
        IIDX25music.set_attribute("pgnum", str(score["pgnum"]))
        IIDX25music.set_attribute("pid", "51")
        IIDX25music.set_attribute("method", "play")
        call.add_child(IIDX25music)

        # Swap with server
        resp = self.exchange("", call)

        # Verify nodes that cause crashes if they don't exist
        self.assert_path(resp, "response/IIDX25music/@clid")
        self.assert_path(resp, "response/IIDX25music/@crate")
        self.assert_path(resp, "response/IIDX25music/@frate")
        self.assert_path(resp, "response/IIDX25music/@mid")

    def verify_iidx25pc_playend(self, lid: str, shop_name: str) -> None:
        call = self.call_node()

        # Construct node
        IIDX25pc = Node.void("IIDX25pc")
        IIDX25pc.set_attribute("cltype", "0")
        IIDX25pc.set_attribute("bookkeep", "0")
        IIDX25pc.set_attribute("mode", "1")
        IIDX25pc.set_attribute("pay_coin", "1")
        IIDX25pc.set_attribute("method", "playend")
        IIDX25pc.set_attribute("company_code", "")
        IIDX25pc.set_attribute("consumer_code", "")
        IIDX25pc.set_attribute("location_name", shop_name)
        IIDX25pc.set_attribute("lid", lid)
        call.add_child(IIDX25pc)

        # Swap with server
        resp = self.exchange("", call)

        # Verify nodes that cause crashes if they don't exist
        self.assert_path(resp, "response/IIDX25pc")

    def verify_iidx25music_breg(self, iidxid: int, score: Dict[str, int]) -> None:
        call = self.call_node()

        # Construct node
        IIDX25music = Node.void("IIDX25music")
        IIDX25music.set_attribute("gnum", str(score["gnum"]))
        IIDX25music.set_attribute("iidxid", str(iidxid))
        IIDX25music.set_attribute("mid", str(score["id"]))
        IIDX25music.set_attribute("method", "breg")
        IIDX25music.set_attribute("pgnum", str(score["pgnum"]))
        IIDX25music.set_attribute("cflg", str(score["clear_status"]))
        call.add_child(IIDX25music)

        # Swap with server
        resp = self.exchange("", call)

        # Verify nodes that cause crashes if they don't exist
        self.assert_path(resp, "response/IIDX25music")

    def verify_iidx25grade_raised(
        self, iidxid: int, shop_name: str, dantype: str
    ) -> None:
        call = self.call_node()

        # Construct node
        IIDX25grade = Node.void("IIDX25grade")
        IIDX25grade.set_attribute("opname", shop_name)
        IIDX25grade.set_attribute("is_mirror", "0")
        IIDX25grade.set_attribute("oppid", "51")
        IIDX25grade.set_attribute("achi", "50")
        IIDX25grade.set_attribute("cstage", "4")
        IIDX25grade.set_attribute("gid", "5")
        IIDX25grade.set_attribute("iidxid", str(iidxid))
        IIDX25grade.set_attribute("gtype", "0" if dantype == "sp" else "1")
        IIDX25grade.set_attribute("is_ex", "0")
        IIDX25grade.set_attribute("pside", "0")
        IIDX25grade.set_attribute("method", "raised")
        call.add_child(IIDX25grade)

        # Swap with server
        resp = self.exchange("", call)

        # Verify nodes that cause crashes if they don't exist
        self.assert_path(resp, "response/IIDX25grade/@pnum")

    def verify_iidx25ranking_entry(
        self, iidxid: int, shop_name: str, coursetype: str
    ) -> None:
        call = self.call_node()

        # Construct node
        IIDX25ranking = Node.void("IIDX25ranking")
        IIDX25ranking.set_attribute("opname", shop_name)
        IIDX25ranking.set_attribute("clr", "4")
        IIDX25ranking.set_attribute("pgnum", "1771")
        IIDX25ranking.set_attribute("coid", "2")
        IIDX25ranking.set_attribute("method", "entry")
        IIDX25ranking.set_attribute("opt", "8208")
        IIDX25ranking.set_attribute("opt2", "0")
        IIDX25ranking.set_attribute("oppid", "51")
        IIDX25ranking.set_attribute("cstage", "4")
        IIDX25ranking.set_attribute("gnum", "967")
        IIDX25ranking.set_attribute("pside", "1")
        IIDX25ranking.set_attribute("clid", "1")
        IIDX25ranking.set_attribute("regist_type", "0" if coursetype == "ir" else "1")
        IIDX25ranking.set_attribute("iidxid", str(iidxid))
        call.add_child(IIDX25ranking)

        # Swap with server
        resp = self.exchange("", call)

        # Verify nodes that cause crashes if they don't exist
        self.assert_path(resp, "response/IIDX25ranking/@anum")
        self.assert_path(resp, "response/IIDX25ranking/@jun")

    def verify_iidx25ranking_classicentry(self, iidxid: int) -> None:
        call = self.call_node()

        # Construct node
        IIDX25ranking = Node.void("IIDX25ranking")
        IIDX25ranking.set_attribute("clear_stage", "4")
        IIDX25ranking.set_attribute("clear_flg", "4")
        IIDX25ranking.set_attribute("course_id", "2")
        IIDX25ranking.set_attribute("score", "4509")
        IIDX25ranking.set_attribute("gnum", "967")
        IIDX25ranking.set_attribute("iidx_id", str(iidxid))
        IIDX25ranking.set_attribute("method", "classicentry")
        IIDX25ranking.set_attribute("pgnum", "1771")
        IIDX25ranking.set_attribute("play_style", "1")
        call.add_child(IIDX25ranking)

        # Swap with server
        resp = self.exchange("", call)

        # Verify nodes that cause crashes if they don't exist
        self.assert_path(resp, "response/IIDX25ranking/@status")

    def verify_iidx25music_arenacpu(self) -> None:
        call = self.call_node()
        IIDX25music = Node.void("IIDX25music")
        call.add_child(IIDX25music)
        IIDX25music.set_attribute("method", "arenaCPU")
        music_list = Node.void("music_list")
        IIDX25music.add_child(music_list)
        music_list.add_child(Node.s32("index", 0))
        music_list.add_child(Node.s32("music_id", 26072))
        music_list.add_child(Node.s32("note_style", 0))
        music_list.add_child(Node.s32("note_grade", 2))
        music_list.add_child(Node.s32("total_notes", 1857))
        music_list_1 = Node.void("music_list")
        IIDX25music.add_child(music_list_1)
        music_list_1.add_child(Node.s32("index", 1))
        music_list_1.add_child(Node.s32("music_id", 25020))
        music_list_1.add_child(Node.s32("note_style", 0))
        music_list_1.add_child(Node.s32("note_grade", 0))
        music_list_1.add_child(Node.s32("total_notes", 483))
        music_list_2 = Node.void("music_list")
        IIDX25music.add_child(music_list_2)
        music_list_2.add_child(Node.s32("index", 2))
        music_list_2.add_child(Node.s32("music_id", 2000))
        music_list_2.add_child(Node.s32("note_style", 0))
        music_list_2.add_child(Node.s32("note_grade", 0))
        music_list_2.add_child(Node.s32("total_notes", 360))
        music_list_3 = Node.void("music_list")
        IIDX25music.add_child(music_list_3)
        music_list_3.add_child(Node.s32("index", 3))
        music_list_3.add_child(Node.s32("music_id", 19020))
        music_list_3.add_child(Node.s32("note_style", 0))
        music_list_3.add_child(Node.s32("note_grade", 0))
        music_list_3.add_child(Node.s32("total_notes", 404))
        cpu_list = Node.void("cpu_list")
        IIDX25music.add_child(cpu_list)
        cpu_list.add_child(Node.s32("index", 0))
        cpu_list.add_child(Node.s32("play_style", 0))
        cpu_list.add_child(Node.s32("arena_class", 0))
        cpu_list.add_child(Node.s32("grade_id", -1))
        cpu_list_1 = Node.void("cpu_list")
        IIDX25music.add_child(cpu_list_1)
        cpu_list_1.add_child(Node.s32("index", 1))
        cpu_list_1.add_child(Node.s32("play_style", 0))
        cpu_list_1.add_child(Node.s32("arena_class", 0))
        cpu_list_1.add_child(Node.s32("grade_id", 6))
        cpu_list_2 = Node.void("cpu_list")
        IIDX25music.add_child(cpu_list_2)
        cpu_list_2.add_child(Node.s32("index", 2))
        cpu_list_2.add_child(Node.s32("play_style", 0))
        cpu_list_2.add_child(Node.s32("arena_class", 0))
        cpu_list_2.add_child(Node.s32("grade_id", 6))
        cpu_list_3 = Node.void("cpu_list")
        IIDX25music.add_child(cpu_list_3)
        cpu_list_3.add_child(Node.s32("index", 3))
        cpu_list_3.add_child(Node.s32("play_style", 0))
        cpu_list_3.add_child(Node.s32("arena_class", 0))
        cpu_list_3.add_child(Node.s32("grade_id", 6))
        # Swap with server
        resp = self.exchange("", call)

        self.assert_path(resp, "response/IIDX25music/cpu_score_list/score_list/score")
        self.assert_path(
            resp, "response/IIDX25music/cpu_score_list/score_list/enable_score"
        )
        self.assert_path(resp, "response/IIDX25music/cpu_score_list/score_list/ghost")
        self.assert_path(
            resp, "response/IIDX25music/cpu_score_list/score_list/enable_ghost"
        )

    def verify_iidx25gamesystem_systeminfo(self, lid: str) -> None:
        call = self.call_node()
        IIDX25gameSystem = Node.void("IIDX25gameSystem")
        call.add_child(IIDX25gameSystem)
        IIDX25gameSystem.set_attribute("method", "systemInfo")
        IIDX25gameSystem.add_child(Node.s32("ver", 7))
        IIDX25gameSystem.add_child(Node.string("location_id", lid))

        # Swap with server
        resp = self.exchange("", call)

        self.assert_path(resp, "response/IIDX25gameSystem/arena_schedule/phase")

    def verify(self, cardid: Optional[str]) -> None:
        # Verify boot sequence is okay
        self.verify_services_get(
            expected_services=[
                "pcbtracker",
                "pcbevent",
                "local",
                "message",
                "facility",
                "cardmng",
                "package",
                "posevent",
                "pkglist",
                "dlstatus",
                "eacoin",
                "lobby",
                "ntp",
                "keepalive",
            ]
        )
        paseli_enabled = self.verify_pcbtracker_alive()
        self.verify_package_list()
        self.verify_message_get()
        lid = self.verify_facility_get()
        self.verify_pcbevent_put()
        self.verify_iidx25shop_getname(lid)
        self.verify_iidx25pc_common()
        self.verify_iidx25music_crate()
        self.verify_iidx25shop_getconvention(lid)
        self.verify_iidx25ranking_getranker(lid)
        self.verify_iidx25shop_sentinfo(lid, "newname1")
        self.verify_iidx25gamesystem_systeminfo(lid)
        self.verify_iidx25music_arenacpu()

        # Verify card registration and profile lookup
        if cardid is not None:
            card = cardid
        else:
            card = self.random_card()
            print(f"Generated random card ID {card} for use.")

        if cardid is None:
            self.verify_cardmng_inquire(
                card, msg_type="unregistered", paseli_enabled=paseli_enabled
            )
            ref_id = self.verify_cardmng_getrefid(card)
            if len(ref_id) != 16:
                raise Exception(
                    f"Invalid refid '{ref_id}' returned when registering card"
                )
            if ref_id != self.verify_cardmng_inquire(
                card, msg_type="new", paseli_enabled=paseli_enabled
            ):
                raise Exception(f"Invalid refid '{ref_id}' returned when querying card")
            self.verify_iidx25pc_reg(ref_id, card, lid)
            self.verify_iidx25pc_get(ref_id, card, lid)
        else:
            print("Skipping new card checks for existing card")
            ref_id = self.verify_cardmng_inquire(
                card, msg_type="query", paseli_enabled=paseli_enabled
            )

        # Verify pin handling and return card handling
        self.verify_cardmng_authpass(ref_id, correct=True)
        self.verify_cardmng_authpass(ref_id, correct=False)
        if ref_id != self.verify_cardmng_inquire(
            card, msg_type="query", paseli_enabled=paseli_enabled
        ):
            raise Exception(f"Invalid refid '{ref_id}' returned when querying card")

        if cardid is None:
            # Verify score handling
            profile = self.verify_iidx25pc_get(ref_id, card, lid)
            if profile["sp_dan"] != -1:
                raise Exception("Somehow has SP DAN ranking on new profile!")
            if profile["dp_dan"] != -1:
                raise Exception("Somehow has DP DAN ranking on new profile!")
            if profile["deller"] != 0:
                raise Exception("Somehow has deller on new profile!")
            if len(profile["ir_data"].keys()) > 0:
                raise Exception("Somehow has internet ranking data on new profile!")
            if len(profile["secret_course_data"].keys()) > 0:
                raise Exception("Somehow has secret course data on new profile!")
            if len(profile["expert_point"].keys()) > 0:
                raise Exception("Somehow has expert point data on new profile!")
            scores = self.verify_iidx25music_getrank(profile["extid"])
            if len(scores.keys()) > 0:
                raise Exception("Somehow have scores on a new profile!")

            for phase in [1, 2]:
                if phase == 1:
                    dummyscores = [
                        # An okay score on a chart
                        {
                            "id": 1000,
                            "chart": 2,
                            "clear_status": 4,
                            "pgnum": 123,
                            "gnum": 123,
                            "mnum": 5,
                        },
                        # A good score on an easier chart of the same song
                        {
                            "id": 1000,
                            "chart": 0,
                            "clear_status": 7,
                            "pgnum": 246,
                            "gnum": 0,
                            "mnum": 0,
                        },
                        # A bad score on a hard chart
                        {
                            "id": 1003,
                            "chart": 2,
                            "clear_status": 1,
                            "pgnum": 10,
                            "gnum": 20,
                            "mnum": 50,
                        },
                        # A terrible score on an easy chart
                        {
                            "id": 1003,
                            "chart": 0,
                            "clear_status": 1,
                            "pgnum": 2,
                            "gnum": 5,
                            "mnum": 75,
                        },
                    ]
                if phase == 2:
                    dummyscores = [
                        # A better score on the same chart
                        {
                            "id": 1000,
                            "chart": 2,
                            "clear_status": 5,
                            "pgnum": 234,
                            "gnum": 234,
                            "mnum": 3,
                        },
                        # A worse score on another same chart
                        {
                            "id": 1000,
                            "chart": 0,
                            "clear_status": 4,
                            "pgnum": 123,
                            "gnum": 123,
                            "mnum": 35,
                            "expected_clear_status": 7,
                            "expected_ex_score": 492,
                            "expected_miss_count": 0,
                        },
                    ]

                for dummyscore in dummyscores:
                    self.verify_iidx25music_reg(profile["extid"], lid, dummyscore)
                self.verify_iidx25pc_visit(profile["extid"], lid)
                self.verify_iidx25pc_save(profile["extid"], card, lid)
                scores = self.verify_iidx25music_getrank(profile["extid"])
                for score in dummyscores:
                    data = scores.get(score["id"], {}).get(score["chart"], None)
                    if data is None:
                        raise Exception(
                            f'Expected to get score back for song {score["id"]} chart {score["chart"]}!'
                        )

                    if "expected_ex_score" in score:
                        expected_score = score["expected_ex_score"]
                    else:
                        expected_score = (score["pgnum"] * 2) + score["gnum"]
                    if "expected_clear_status" in score:
                        expected_clear_status = score["expected_clear_status"]
                    else:
                        expected_clear_status = score["clear_status"]
                    if "expected_miss_count" in score:
                        expected_miss_count = score["expected_miss_count"]
                    else:
                        expected_miss_count = score["mnum"]

                    if data["ex_score"] != expected_score:
                        raise Exception(
                            f'Expected a score of \'{expected_score}\' for song \'{score["id"]}\' chart \'{score["chart"]}\' but got score \'{data["ex_score"]}\''
                        )
                    if data["clear_status"] != expected_clear_status:
                        raise Exception(
                            f'Expected a clear status of \'{expected_clear_status}\' for song \'{score["id"]}\' chart \'{score["chart"]}\' but got clear status \'{data["clear_status"]}\''
                        )
                    if data["miss_count"] != expected_miss_count:
                        raise Exception(
                            f'Expected a miss count of \'{expected_miss_count}\' for song \'{score["id"]}\' chart \'{score["chart"]}\' but got miss count \'{data["miss_count"]}\''
                        )

                    # Verify we can fetch our own ghost
                    ex_score, ghost = self.verify_iidx25music_appoint(
                        profile["extid"], score["id"], score["chart"]
                    )
                    if ex_score != expected_score:
                        raise Exception(
                            f'Expected a score of \'{expected_score}\' for song \'{score["id"]}\' chart \'{score["chart"]}\' but got score \'{data["ex_score"]}\''
                        )

                    if len(ghost) != 64:
                        raise Exception(f"Wrong ghost length {len(ghost)} for ghost!")
                    for g in ghost:
                        if g != 0x01:
                            raise Exception(
                                f'Got back wrong ghost data for song \'{score["id"]}\' chart \'{score["chart"]}\''
                            )

                # Sleep so we don't end up putting in score history on the same second
                time.sleep(1)

            # Verify that we can save/load expert points
            self.verify_iidx25pc_save(
                profile["extid"],
                card,
                lid,
                {"course_id": 1, "n_point": 0, "h_point": 500, "a_point": 0},
            )
            profile = self.verify_iidx25pc_get(ref_id, card, lid)
            if sorted(profile["expert_point"].keys()) != [1]:
                raise Exception("Got back wrong number of expert course points!")
            if profile["expert_point"][1] != {
                "n_point": 0,
                "h_point": 500,
                "a_point": 0,
            }:
                raise Exception("Got back wrong expert points after saving!")
            self.verify_iidx25pc_save(
                profile["extid"],
                card,
                lid,
                {"course_id": 1, "n_point": 0, "h_point": 1000, "a_point": 0},
            )
            profile = self.verify_iidx25pc_get(ref_id, card, lid)
            if sorted(profile["expert_point"].keys()) != [1]:
                raise Exception("Got back wrong number of expert course points!")
            if profile["expert_point"][1] != {
                "n_point": 0,
                "h_point": 1000,
                "a_point": 0,
            }:
                raise Exception("Got back wrong expert points after saving!")
            self.verify_iidx25pc_save(
                profile["extid"],
                card,
                lid,
                {"course_id": 2, "n_point": 0, "h_point": 0, "a_point": 500},
            )
            profile = self.verify_iidx25pc_get(ref_id, card, lid)
            if sorted(profile["expert_point"].keys()) != [1, 2]:
                raise Exception("Got back wrong number of expert course points!")
            if profile["expert_point"][1] != {
                "n_point": 0,
                "h_point": 1000,
                "a_point": 0,
            }:
                raise Exception("Got back wrong expert points after saving!")
            if profile["expert_point"][2] != {
                "n_point": 0,
                "h_point": 0,
                "a_point": 500,
            }:
                raise Exception("Got back wrong expert points after saving!")

            # Verify that a player without a card can play
            self.verify_iidx25pc_playstart()
            self.verify_iidx25music_play(
                {
                    "id": 1000,
                    "chart": 2,
                    "clear_status": 4,
                    "pgnum": 123,
                    "gnum": 123,
                }
            )
            self.verify_iidx25pc_playend(lid, "newname1")

            # Verify shop name change setting
            self.verify_iidx25shop_savename(lid, "newname1")
            newname = self.verify_iidx25shop_getname(lid)
            if newname != "newname1":
                raise Exception("Invalid shop name returned after change!")
            self.verify_iidx25shop_savename(lid, "newname2")
            newname = self.verify_iidx25shop_getname(lid)
            if newname != "newname2":
                raise Exception("Invalid shop name returned after change!")

            # Verify beginner score saving
            self.verify_iidx25music_breg(
                profile["extid"],
                {
                    "id": 1000,
                    "clear_status": 4,
                    "pgnum": 123,
                    "gnum": 123,
                },
            )
            scores = self.verify_iidx25music_getrank(profile["extid"])
            if 1000 not in scores:
                raise Exception(
                    f"Didn't get expected scores back for song {1000} beginner chart!"
                )
            if 6 not in scores[1000]:
                raise Exception(f"Didn't get beginner score back for song {1000}!")
            if scores[1000][6] != {"clear_status": 4, "ex_score": -1, "miss_count": -1}:
                raise Exception("Didn't get correct status back from beginner save!")

            # Verify DAN score saving and loading
            self.verify_iidx25grade_raised(profile["extid"], newname, "sp")
            self.verify_iidx25grade_raised(profile["extid"], newname, "dp")
            profile = self.verify_iidx25pc_get(ref_id, card, lid)
            if profile["sp_dan"] != 5:
                raise Exception("Got wrong DAN score back for SP!")
            if profile["dp_dan"] != 5:
                raise Exception("Got wrong DAN score back for DP!")

            # Verify secret course and internet ranking course saving
            self.verify_iidx25ranking_entry(profile["extid"], newname, "ir")
            self.verify_iidx25ranking_entry(profile["extid"], newname, "secret")
            self.verify_iidx25ranking_classicentry(profile["extid"])
            profile = self.verify_iidx25pc_get(ref_id, card, lid)
            for ptype in ["ir_data", "secret_course_data", "classic_course_data"]:
                if profile[ptype] != {
                    2: {1: {"clear_status": 4, "pgnum": 1771, "gnum": 967}}
                }:
                    raise Exception(
                        f"Invalid data {profile[ptype]} returned on profile load for {ptype}!"
                    )
        else:
            print("Skipping score checks for existing card")

        # Verify paseli handling
        if paseli_enabled:
            print("PASELI enabled for this PCBID, executing PASELI checks")
        else:
            print("PASELI disabled for this PCBID, skipping PASELI checks")
            return

        sessid, balance = self.verify_eacoin_checkin(card)
        if balance == 0:
            print("Skipping PASELI consume check because card has 0 balance")
        else:
            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
        self.verify_eacoin_checkout(sessid)