"""虎牙活动积分相关 JCE 结构。"""

from .taf_protocol import TafInputStream, TafOutputStream, TafStruct, TafType


class ActivityUserId(TafStruct):
    """活动组件使用的用户标识。"""

    def __init__(self):
        self.lUid: int = 0
        self.sGuid: str = ""
        self.sToken: str = ""
        self.sHuYaUA: str = "webh5&0.0.1&websocket&&diypc_52775"
        self.sCookie: str = ""
        self.iTokenType: int = 0
        self.sDeviceInfo: str = ""
        self.sQIMEI: str = ""

    def write_to(self, os: TafOutputStream):
        os.write_int64(0, self.lUid)
        os.write_string(1, self.sGuid)
        os.write_string(2, self.sToken)
        os.write_string(3, self.sHuYaUA)
        os.write_string(4, self.sCookie)
        os.write_int32(5, self.iTokenType)
        os.write_string(6, self.sDeviceInfo)
        os.write_string(7, self.sQIMEI)

    def read_from(self, ins: TafInputStream):
        self.lUid = ins.read_int64(0, default=self.lUid)
        self.sGuid = ins.read_string(1, default=self.sGuid)
        self.sToken = ins.read_string(2, default=self.sToken)
        self.sHuYaUA = ins.read_string(3, default=self.sHuYaUA)
        self.sCookie = ins.read_string(4, default=self.sCookie)
        self.iTokenType = ins.read_int32(5, default=self.iTokenType)
        self.sDeviceInfo = ins.read_string(6, default=self.sDeviceInfo)
        self.sQIMEI = ins.read_string(7, default=self.sQIMEI)


class GetUserScoreReq(TafStruct):
    """webActUI.getUserScore 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.sid: int = 0

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_int32(1, self.sid)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.sid = ins.read_int32(1, default=self.sid)


class GetUserScoreResp(TafStruct):
    """webActUI.getUserScore 响应。"""

    def __init__(self):
        self.status: int = 0
        self.msg: str = ""
        self.gainScore: int = 0
        self.usedScore: int = 0
        self.newGainScore: int = 0
        self.newUsedScore: int = 0
        self.score: int = 0
        self.isOpenExchangeTip: int = 0

    @property
    def available_score(self) -> int:
        """按现网页组件逻辑计算可用积分。"""
        if self.newGainScore or self.newUsedScore:
            return max(0, int(self.newGainScore) - int(self.newUsedScore))
        return int(self.score)

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)
        self.gainScore = ins.read_int32(2, default=self.gainScore)
        self.usedScore = ins.read_int32(3, default=self.usedScore)
        self.newGainScore = ins.read_int64(4, default=self.newGainScore)
        self.newUsedScore = ins.read_int64(5, default=self.newUsedScore)
        self.score = ins.read_int64(6, default=self.score)
        self.isOpenExchangeTip = ins.read_int32(7, default=self.isOpenExchangeTip)

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.status)
        os.write_string(1, self.msg)
        os.write_int32(2, self.gainScore)
        os.write_int32(3, self.usedScore)
        os.write_int64(4, self.newGainScore)
        os.write_int64(5, self.newUsedScore)
        os.write_int64(6, self.score)
        os.write_int32(7, self.isOpenExchangeTip)

    def to_dict(self) -> dict:
        return {
            "status": self.status,
            "msg": self.msg,
            "gain_score": self.gainScore,
            "used_score": self.usedScore,
            "new_gain_score": self.newGainScore,
            "new_used_score": self.newUsedScore,
            "score": self.score,
            "available_score": self.available_score,
            "is_open_exchange_tip": self.isOpenExchangeTip,
        }


class GetActInfoReq(TafStruct):
    """webActUI.getActInfo 请求。"""

    def __init__(self):
        self.actId = 0
        self.actUuid = ""
        self.appSource = ""

    def write_to(self, os: TafOutputStream):
        os.write_int64(0, self.actId)
        os.write_string(1, self.actUuid)
        os.write_string(2, self.appSource)

    def read_from(self, ins: TafInputStream):
        self.actId = ins.read_int64(0, default=self.actId)
        self.actUuid = ins.read_string(1, default=self.actUuid)
        self.appSource = ins.read_string(2, default=self.appSource)


class ActInfoItem(TafStruct):
    def __init__(self):
        self.actId = 0
        self.name = ""
        self.startTime = 0
        self.endTime = 0
        self.moduleId = 0
        self.outerActId = ""
        self.gameIdList = ""
        self.gid = 0

    def read_from(self, ins: TafInputStream):
        for tag, attr, reader in (
            (0, "actId", ins.read_int64), (1, "name", ins.read_string),
            (2, "startTime", ins.read_int64), (3, "endTime", ins.read_int64),
            (4, "moduleId", ins.read_int64), (5, "outerActId", ins.read_string),
            (6, "gameIdList", ins.read_string), (8, "gid", ins.read_int64),
        ):
            setattr(self, attr, reader(tag, default=getattr(self, attr)))

    def write_to(self, os: TafOutputStream):
        os.write_int64(0, self.actId)
        os.write_string(1, self.name)
        os.write_int64(2, self.startTime)
        os.write_int64(3, self.endTime)
        os.write_int64(4, self.moduleId)
        os.write_string(5, self.outerActId)
        os.write_string(6, self.gameIdList)
        os.write_int64(8, self.gid)

    def to_dict(self) -> dict:
        return {"act_id": self.actId, "name": self.name, "start_time": self.startTime,
                "end_time": self.endTime, "module_id": self.moduleId,
                "outer_act_id": self.outerActId, "game_id_list": self.gameIdList,
                "gid": self.gid}


class GetActInfoResp(TafStruct):
    def __init__(self):
        self.status = 0
        self.msg = ""
        self.info: ActInfoItem | None = None

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)
        self.info = ins.read_struct(2, ActInfoItem)

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.status)
        os.write_string(1, self.msg)
        if self.info:
            os.write_struct(2, self.info)

    def to_dict(self) -> dict:
        return {"status": self.status, "msg": self.msg,
                "info": self.info.to_dict() if self.info else None}


class GetActPrizeListReq(TafStruct):
    """webActUI.getActPrizeList 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.sid: int = 0

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_int32(1, self.sid)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.sid = ins.read_int32(1, default=self.sid)


class GetUserPrizeRecordsReq(TafStruct):
    """webActUI.getUserPrizeRecords 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.sid: int = 0

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_int32(1, self.sid)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.sid = ins.read_int32(1, default=self.sid)


class ScoreExchangePrizeReq(TafStruct):
    """webActUI.scoreExchangePrize 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.sid: int = 0
        self.pid: int = 0
        self.ip: str = ""
        self.clientEnv: dict = {}
        self.source: str = ""
        self.isRole: int = 1

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_int32(1, self.sid)
        os.write_int32(2, self.pid)
        os.write_string(3, self.ip)
        os.write_map(4, self.clientEnv)
        os.write_string(5, self.source)
        os.write_int32(6, self.isRole)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.sid = ins.read_int32(1, default=self.sid)
        self.pid = ins.read_int32(2, default=self.pid)
        self.ip = ins.read_string(3, default=self.ip)
        self.clientEnv = ins.read_map(4)
        self.source = ins.read_string(5, default=self.source)
        self.isRole = ins.read_int32(6, default=self.isRole)


class GetActPrizeDetailReq(TafStruct):
    """webActUI.getActPrizeDetail 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.sid: int = 0
        self.pid: int = 0

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_int32(1, self.sid)
        os.write_int32(2, self.pid)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.sid = ins.read_int32(1, default=self.sid)
        self.pid = ins.read_int32(2, default=self.pid)


class ActPrizeDetailItem(TafStruct):
    """兑换详情中的奖品和服务端限制字段。"""

    def __init__(self):
        self.prizeId = 0
        self.name = ""
        self.score = 0
        self.icon = ""
        self.frequency = 0
        self.frequencyLimit = 0
        self.num = 0
        self.status = 0
        self.leftNum = 0
        self.isShowNum = 0
        self.percent = ""
        self.newScore = 0
        self.categoryId = ""
        self.usedNum = 0
        self.goodType = 0
        self.commonPrizeId = 0
        self.updateTime = 0
        self.isCanExchange = 0
        self.exchangeStartTime = 0
        self.exchangeEndTime = 0
        self.startTimeSlot = ""
        self.endTimeSlot = ""
        self.isTodayLimit = 0
        self.isUserLimit = 0

    def read_from(self, ins: TafInputStream):
        readers = {
            0: ("prizeId", ins.read_int64), 2: ("name", ins.read_string),
            3: ("score", ins.read_int64), 5: ("icon", ins.read_string),
            6: ("frequency", ins.read_int32), 7: ("frequencyLimit", ins.read_int32),
            8: ("num", ins.read_int64), 9: ("status", ins.read_int32),
            10: ("leftNum", ins.read_int64), 11: ("isShowNum", ins.read_int32),
            12: ("percent", ins.read_string), 13: ("newScore", ins.read_int64),
            14: ("categoryId", ins.read_string), 17: ("usedNum", ins.read_int64),
            18: ("goodType", ins.read_int32), 22: ("commonPrizeId", ins.read_int64),
            23: ("updateTime", ins.read_int64), 24: ("isCanExchange", ins.read_int32),
            25: ("exchangeStartTime", ins.read_int64), 26: ("exchangeEndTime", ins.read_int64),
            27: ("startTimeSlot", ins.read_string), 28: ("endTimeSlot", ins.read_string),
            29: ("isTodayLimit", ins.read_int32), 30: ("isUserLimit", ins.read_int32),
        }
        while True:
            pos = ins.buf.tell()
            tag, dtype = ins.read_head()
            if dtype == TafType.STRUCT_END:
                ins.buf.seek(pos)
                return
            item = readers.get(tag)
            if item is None:
                ins.skip_field(dtype)
                continue
            name, reader = item
            ins.buf.seek(pos)
            setattr(self, name, reader(tag, default=getattr(self, name)))

    def write_to(self, os: TafOutputStream):
        os.write_int64(0, self.prizeId)
        os.write_string(2, self.name)
        os.write_int64(3, self.score)
        os.write_string(5, self.icon)
        os.write_int32(6, self.frequency)
        os.write_int32(7, self.frequencyLimit)
        os.write_int64(8, self.num)
        os.write_int32(9, self.status)
        os.write_int64(10, self.leftNum)
        os.write_int32(11, self.isShowNum)
        os.write_string(12, self.percent)
        os.write_int64(13, self.newScore)
        os.write_string(14, self.categoryId)
        os.write_int64(17, self.usedNum)
        os.write_int32(18, self.goodType)
        os.write_int64(22, self.commonPrizeId)
        os.write_int64(23, self.updateTime)
        os.write_int32(24, self.isCanExchange)
        os.write_int64(25, self.exchangeStartTime)
        os.write_int64(26, self.exchangeEndTime)
        os.write_string(27, self.startTimeSlot)
        os.write_string(28, self.endTimeSlot)
        os.write_int32(29, self.isTodayLimit)
        os.write_int32(30, self.isUserLimit)

    def to_dict(self) -> dict:
        return {
            "product_id": str(self.prizeId), "name": self.name, "score": self.score,
            "icon": self.icon, "frequency": self.frequency,
            "frequency_limit": self.frequencyLimit, "num": self.num,
            "status": self.status, "left_num": self.leftNum,
            "is_show_num": self.isShowNum, "percent": self.percent,
            "new_score": self.newScore, "category_id": self.categoryId,
            "used_num": self.usedNum, "good_type": self.goodType,
            "common_prize_id": self.commonPrizeId, "update_time": self.updateTime,
            "is_can_exchange": self.isCanExchange,
            "exchange_start_time": self.exchangeStartTime,
            "exchange_end_time": self.exchangeEndTime,
            "start_time_slot": self.startTimeSlot, "end_time_slot": self.endTimeSlot,
            "is_today_limit": self.isTodayLimit, "is_user_limit": self.isUserLimit,
        }


class GetActPrizeDetailResp(TafStruct):
    """webActUI.getActPrizeDetail 响应。"""

    def __init__(self):
        self.status = 0
        self.msg = ""
        self.prize: ActPrizeDetailItem | None = None
        self.detailStatus = 0

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)
        outer = ins.read_struct(2, _ActPrizeDetailEnvelope)
        if outer:
            self.prize = outer.prize
            self.detailStatus = outer.detailStatus

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.status)
        os.write_string(1, self.msg)
        envelope = _ActPrizeDetailEnvelope()
        envelope.prize = self.prize
        envelope.detailStatus = self.detailStatus
        os.write_struct(2, envelope)

    def to_dict(self) -> dict:
        return {"status": self.status, "msg": self.msg,
                "prize": self.prize.to_dict() if self.prize else None,
                "detail_status": self.detailStatus}


class _ActPrizeDetailEnvelope(TafStruct):
    def __init__(self):
        self.prize: ActPrizeDetailItem | None = None
        self.detailStatus = 0

    def read_from(self, ins: TafInputStream):
        self.prize = ins.read_struct(0, ActPrizeDetailItem)
        self.detailStatus = ins.read_int32(1, default=self.detailStatus)
        while True:
            pos = ins.buf.tell()
            _tag, dtype = ins.read_head()
            if dtype == TafType.STRUCT_END:
                ins.buf.seek(pos)
                return
            ins.skip_field(dtype)

    def write_to(self, os: TafOutputStream):
        if self.prize:
            os.write_struct(0, self.prize)
        os.write_int32(1, self.detailStatus)


class ExchangeInfo(TafStruct):
    """积分兑换结果信息。"""

    def __init__(self):
        self.pid: int = 0
        self.exchangeScore: int = 0
        self.desc: str = ""

    def read_from(self, ins: TafInputStream):
        self.pid = ins.read_int32(1, default=self.pid)
        self.exchangeScore = ins.read_int64(2, default=self.exchangeScore)
        self.desc = ins.read_string(3, default=self.desc)

    def write_to(self, os: TafOutputStream):
        os.write_int32(1, self.pid)
        os.write_int64(2, self.exchangeScore)
        os.write_string(3, self.desc)

    def to_dict(self) -> dict:
        return {
            "pid": self.pid,
            "exchange_score": self.exchangeScore,
            "desc": self.desc,
        }


class ExchangeActPreCondition(TafStruct):
    """兑换前置条件提示。"""

    def __init__(self):
        self.conditionType: int = 0
        self.conditionParams: dict = {}
        self.tip: str = ""
        self.jumpUrl: str = ""
        self.buttonDesc: str = ""

    def read_from(self, ins: TafInputStream):
        self.conditionType = ins.read_int32(0, default=self.conditionType)
        self.conditionParams = ins.read_map(1)
        self.tip = ins.read_string(2, default=self.tip)
        self.jumpUrl = ins.read_string(3, default=self.jumpUrl)
        self.buttonDesc = ins.read_string(4, default=self.buttonDesc)

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.conditionType)
        os.write_map(1, self.conditionParams)
        os.write_string(2, self.tip)
        os.write_string(3, self.jumpUrl)
        os.write_string(4, self.buttonDesc)

    def to_dict(self) -> dict:
        return {
            "condition_type": self.conditionType,
            "condition_params": dict(self.conditionParams),
            "tip": self.tip,
            "jump_url": self.jumpUrl,
            "button_desc": self.buttonDesc,
        }


class ScoreExchangePrizeResp(TafStruct):
    """webActUI.scoreExchangePrize 响应。"""

    def __init__(self):
        self.status: int = 0
        self.msg: str = ""
        self.orderId: str = ""
        self.exchangeInfo = ExchangeInfo()
        self.actPreCondition = ExchangeActPreCondition()

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)
        self.orderId = ins.read_string(3, default=self.orderId)
        self.exchangeInfo = ins.read_struct(4, ExchangeInfo) or self.exchangeInfo
        self.actPreCondition = (
            ins.read_struct(5, ExchangeActPreCondition) or self.actPreCondition
        )

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.status)
        os.write_string(1, self.msg)
        os.write_string(3, self.orderId)
        os.write_struct(4, self.exchangeInfo)
        os.write_struct(5, self.actPreCondition)

    def to_dict(self) -> dict:
        return {
            "status": self.status,
            "msg": self.msg,
            "order_id": self.orderId,
            "exchange_info": self.exchangeInfo.to_dict(),
            "act_pre_condition": self.actPreCondition.to_dict(),
        }


class UserPrizeRecordItem(TafStruct):
    """用户兑换记录项，字段来自 getUserPrizeRecords 实测响应。"""

    def __init__(self):
        self.recordId: int = 0
        self.prizeName: str = ""
        self.score: int = 0
        self.exchangeTime: int = 0
        self.prizeStatus: int = 0
        self.prizeType: int = 0
        self.orderId: str = ""
        self.icon: str = ""
        self.prizeId: int = 0
        self.prizeItemId: int = 0
        self.ext: dict = {}
        self.exchangeDate: int = 0

    @staticmethod
    def _status_label(status: int) -> str:
        if status == 0:
            return "未发放"
        if status == 1:
            return "已发放"
        return f"状态{status}"

    def read_from(self, ins: TafInputStream):
        self.recordId = ins.read_int64(0, default=self.recordId)
        self.prizeName = ins.read_string(1, default=self.prizeName)
        self.score = ins.read_int64(2, default=self.score)
        self.exchangeTime = ins.read_int64(3, default=self.exchangeTime)
        self.prizeStatus = ins.read_int32(4, default=self.prizeStatus)
        self.prizeType = ins.read_int32(10, default=self.prizeType)
        self.orderId = ins.read_string(12, default=self.orderId)
        self.icon = ins.read_string(14, default=self.icon)
        self.prizeId = ins.read_int64(16, default=self.prizeId)
        self.prizeItemId = ins.read_int64(19, default=self.prizeItemId)
        self.ext = ins.read_map(20)
        self.exchangeDate = ins.read_int64(21, default=self.exchangeDate)
        while True:
            pos = ins.buf.tell()
            _tag, dtype = ins.read_head()
            if dtype == TafType.STRUCT_END:
                ins.buf.seek(pos)
                return
            ins.skip_field(dtype)

    def write_to(self, os: TafOutputStream):
        pass

    @staticmethod
    def read_list_item(ins: TafInputStream, _tag: int):
        item = UserPrizeRecordItem()
        item.read_from(ins)
        _end_tag, dtype = ins.read_head()
        if dtype != TafType.STRUCT_END:
            raise ValueError(f"期望兑换记录 STRUCT_END，实际 0x{dtype:02x}")
        return item

    def to_dict(self) -> dict:
        return {
            "record_id": self.recordId,
            "prize_name": self.prizeName,
            "score": self.score,
            "exchange_time": self.exchangeTime,
            "exchange_date": self.exchangeDate,
            "prize_status": self.prizeStatus,
            "status_label": self._status_label(self.prizeStatus),
            "order_id": self.orderId,
            "icon": self.icon,
            "prize_id": self.prizeId,
            "prize_type": self.prizeType,
            "prize_item_id": self.prizeItemId,
            "ext": dict(self.ext),
        }


class GetUserPrizeRecordsResp(TafStruct):
    """webActUI.getUserPrizeRecords 响应。"""

    def __init__(self):
        self.status: int = 0
        self.msg: str = ""
        self.records: list[UserPrizeRecordItem] = []

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)
        self.records = ins.read_list(2, item_reader=UserPrizeRecordItem.read_list_item)

    def write_to(self, os: TafOutputStream):
        pass

    def to_dict(self) -> dict:
        records = [item.to_dict() for item in self.records]
        return {
            "status": self.status,
            "msg": self.msg,
            "record_count": len(records),
            "records": records,
        }


class GetActTaskDetailReq(TafStruct):
    """webActUI.getActTaskDetail 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.actId: int = 0

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_int32(1, self.actId)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.actId = ins.read_int32(1, default=self.actId)


class GetActUserTaskDetailReq(TafStruct):
    """webActUI.getActUserTaskDetail 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.actId = 0

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_int64(1, self.actId)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.actId = ins.read_int64(1, default=self.actId)


class UserActTaskItem(TafStruct):
    def __init__(self):
        self.actId = 0
        self.taskId = 0
        self.taskStatus = 0
        self.prizeStatus = 0
        self.taskValue = ""
        self.taskCount = 0
        self.prizeCount = 0
        self.subTaskDetail = 0
        self.extraStatus = 0

    def read_from(self, ins: TafInputStream):
        for tag, attr, reader in (
            (0, "actId", ins.read_int64), (1, "taskId", ins.read_int64),
            (2, "taskStatus", ins.read_int32), (3, "prizeStatus", ins.read_int32),
            (4, "taskValue", ins.read_string), (5, "taskCount", ins.read_int64),
            (6, "prizeCount", ins.read_int64), (8, "subTaskDetail", ins.read_int64),
            (9, "extraStatus", ins.read_int64),
        ):
            setattr(self, attr, reader(tag, default=getattr(self, attr)))

    def write_to(self, os: TafOutputStream):
        os.write_int64(0, self.actId)
        os.write_int64(1, self.taskId)
        os.write_int32(2, self.taskStatus)
        os.write_int32(3, self.prizeStatus)
        os.write_string(4, self.taskValue)
        os.write_int64(5, self.taskCount)
        os.write_int64(6, self.prizeCount)
        os.write_int64(8, self.subTaskDetail)
        os.write_int64(9, self.extraStatus)

    @staticmethod
    def read_list_item(ins: TafInputStream, _tag: int):
        item = UserActTaskItem()
        item.read_from(ins)
        _end, dtype = ins.read_head()
        if dtype != TafType.STRUCT_END:
            raise ValueError(f"期望用户任务 STRUCT_END，实际 0x{dtype:02x}")
        return item

    def to_dict(self) -> dict:
        return {"act_id": self.actId, "task_id": self.taskId,
                "task_status": self.taskStatus, "prize_status": self.prizeStatus,
                "task_value": self.taskValue, "task_count": self.taskCount,
                "prize_count": self.prizeCount, "sub_task_detail": self.subTaskDetail,
                "extra_status": self.extraStatus}


class GetActUserTaskDetailResp(TafStruct):
    def __init__(self):
        self.status = 0
        self.msg = ""
        self.tasks: list[UserActTaskItem] = []

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)
        self.tasks = ins.read_list(2, item_reader=UserActTaskItem.read_list_item)

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.status)
        os.write_string(1, self.msg)
        os.write_list(2, self.tasks)

    def to_dict(self) -> dict:
        return {"status": self.status, "msg": self.msg,
                "task_count": len(self.tasks),
                "tasks": [item.to_dict() for item in self.tasks]}


class ActTaskPrizeInfo(TafStruct):
    """活动任务奖励项，刷新充值商品时只取展示需要字段。"""

    def __init__(self):
        self.actId: int = 0
        self.taskId: int = 0
        self.prizeId: int = 0
        self.name: str = ""
        self.count: int = 0
        self.percentText: str = ""
        self.extra: dict = {}

    def read_from(self, ins: TafInputStream):
        self.actId = ins.read_int64(0, default=self.actId)
        self.taskId = ins.read_int64(1, default=self.taskId)
        self.prizeId = ins.read_int64(2, default=self.prizeId)
        self.name = ins.read_string(3, default=self.name)
        self.count = ins.read_int64(4, default=self.count)
        self.percentText = ins.read_string(9, default=self.percentText)
        self.extra = ins.read_map(12)
        while True:
            pos = ins.buf.tell()
            _tag, dtype = ins.read_head()
            if dtype == TafType.STRUCT_END:
                ins.buf.seek(pos)
                return
            ins.skip_field(dtype)

    def write_to(self, os: TafOutputStream):
        pass

    @staticmethod
    def read_list_item(ins: TafInputStream, _tag: int):
        item = ActTaskPrizeInfo()
        item.read_from(ins)
        _end_tag, dtype = ins.read_head()
        if dtype != TafType.STRUCT_END:
            raise ValueError(f"期望任务奖励 STRUCT_END，实际 0x{dtype:02x}")
        return item

    def to_dict(self) -> dict:
        return {
            "act_id": self.actId,
            "task_id": self.taskId,
            "prize_id": self.prizeId,
            "name": self.name,
            "count": self.count,
            "percent_text": self.percentText,
            "extra": dict(self.extra),
        }


class ActTaskDetailItem(TafStruct):
    """活动任务项，字段位置来自 getActTaskDetail 实测响应。"""

    def __init__(self):
        self.actId: int = 0
        self.taskId: int = 0
        self.name: str = ""
        self.taskStatus: int = 0
        self.taskType: int = 0
        self.limitType: int = 0
        self.taskParams: str = ""
        self.targetValue: str = ""
        self.icon: str = ""
        self.description: str = ""
        self.prizes: list[ActTaskPrizeInfo] = []
        self.taskUrl: str = ""
        self.startTime: str = ""
        self.endTime: str = ""

    @staticmethod
    def _extract_spu_id(text: str) -> str:
        import urllib.parse

        raw = str(text or "")
        if not raw:
            return ""
        query = raw
        if "?" in raw:
            query = raw.split("?", 1)[1]
        if "#" in query and "?" in query.split("#", 1)[1]:
            query = query.split("#", 1)[1].split("?", 1)[1]
        params = urllib.parse.parse_qs(query, keep_blank_values=True)
        for key in ("spuId", "spu_id"):
            value = params.get(key)
            if value and value[0]:
                return value[0]
        for part in raw.replace("#", "&").split("&"):
            if part.startswith("spuId="):
                return urllib.parse.unquote(part.split("=", 1)[1])
        return ""

    def read_from(self, ins: TafInputStream):
        self.actId = ins.read_int64(0, default=self.actId)
        self.taskId = ins.read_int64(1, default=self.taskId)
        self.name = ins.read_string(2, default=self.name)
        self.taskStatus = ins.read_int32(3, default=self.taskStatus)
        self.taskType = ins.read_int32(4, default=self.taskType)
        self.limitType = ins.read_int32(5, default=self.limitType)
        self.taskParams = ins.read_string(6, default=self.taskParams)
        self.targetValue = ins.read_string(7, default=self.targetValue)
        self.icon = ins.read_string(8, default=self.icon)
        self.description = ins.read_string(9, default=self.description)
        self.prizes = ins.read_list(11, item_reader=ActTaskPrizeInfo.read_list_item)
        self.taskUrl = ins.read_string(12, default=self.taskUrl)
        self.startTime = ins.read_string(25, default=self.startTime)
        self.endTime = ins.read_string(26, default=self.endTime)
        while True:
            pos = ins.buf.tell()
            _tag, dtype = ins.read_head()
            if dtype == TafType.STRUCT_END:
                ins.buf.seek(pos)
                return
            ins.skip_field(dtype)

    def write_to(self, os: TafOutputStream):
        pass

    @staticmethod
    def read_list_item(ins: TafInputStream, _tag: int):
        item = ActTaskDetailItem()
        item.read_from(ins)
        _end_tag, dtype = ins.read_head()
        if dtype != TafType.STRUCT_END:
            raise ValueError(f"期望任务 STRUCT_END，实际 0x{dtype:02x}")
        return item

    @property
    def spu_id(self) -> str:
        return self._extract_spu_id(self.taskUrl) or self._extract_spu_id(
            self.taskParams
        )

    def to_dict(self) -> dict:
        return {
            "act_id": self.actId,
            "task_id": self.taskId,
            "name": self.name,
            "task_status": self.taskStatus,
            "task_type": self.taskType,
            "limit_type": self.limitType,
            "task_params": self.taskParams,
            "target_value": self.targetValue,
            "icon": self.icon,
            "description": self.description,
            "task_url": self.taskUrl,
            "spu_id": self.spu_id,
            "start_time": self.startTime,
            "end_time": self.endTime,
            "prizes": [item.to_dict() for item in self.prizes],
        }


class GetActTaskDetailResp(TafStruct):
    """webActUI.getActTaskDetail 响应。"""

    def __init__(self):
        self.status: int = 0
        self.msg: str = ""
        self.tasks: list[ActTaskDetailItem] = []

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)
        self.tasks = ins.read_list(2, item_reader=ActTaskDetailItem.read_list_item)

    def write_to(self, os: TafOutputStream):
        pass

    def to_dict(self) -> dict:
        tasks = [item.to_dict() for item in self.tasks]
        return {
            "status": self.status,
            "msg": self.msg,
            "task_count": len(tasks),
            "tasks": tasks,
        }


class ActPrizeItem(TafStruct):
    """活动商品项，字段位置来自 getActPrizeList 实测响应。"""

    def __init__(self):
        self.prizeId: int = 0
        self.prizeType: int = 0
        self.name: str = ""
        self.score: int = 0
        self.icon: str = ""
        self.stock: int = 0
        self.remainText: str = ""
        self.price: int = 0
        self.categoryId: str = ""
        self.totalRemain: int = 0
        self.rawOrder: int = 0
        self.startTime: int = 0
        self.endTime: int = 0

    def read_from(self, ins: TafInputStream):
        self.prizeId = ins.read_int64(0, default=self.prizeId)
        self.prizeType = ins.read_int32(1, default=self.prizeType)
        self.name = ins.read_string(2, default=self.name)
        self.score = ins.read_int64(3, default=self.score)
        ins.read_int32(4, default=0)
        self.icon = ins.read_string(5, default=self.icon)
        self.stock = ins.read_int64(10, default=self.stock)
        self.remainText = ins.read_string(12, default=self.remainText)
        self.price = ins.read_int64(13, default=self.price)
        self.categoryId = ins.read_string(14, default=self.categoryId)
        self.totalRemain = ins.read_int64(17, default=self.totalRemain)
        self.rawOrder = ins.read_int64(22, default=self.rawOrder)
        self.startTime = ins.read_int64(25, default=self.startTime)
        self.endTime = ins.read_int64(26, default=self.endTime)

    def write_to(self, os: TafOutputStream):
        os.write_int64(0, self.prizeId)
        os.write_int32(1, self.prizeType)
        os.write_string(2, self.name)
        os.write_int64(3, self.score)
        os.write_string(5, self.icon)
        os.write_int64(10, self.stock)
        os.write_string(12, self.remainText)
        os.write_int64(13, self.price)
        os.write_string(14, self.categoryId)
        os.write_int64(17, self.totalRemain)
        os.write_int64(22, self.rawOrder)
        os.write_int64(25, self.startTime)
        os.write_int64(26, self.endTime)

    @staticmethod
    def read_list_item(ins: TafInputStream, _tag: int):
        item = ActPrizeItem()
        item.read_from(ins)
        while True:
            _end_tag, dtype = ins.read_head()
            if dtype == TafType.STRUCT_END:
                break
            ins.skip_field(dtype)
        return item

    @staticmethod
    def _remain_percent_text(value: str) -> str:
        text = str(value or "").strip()
        if not text or text.endswith("%"):
            return text
        try:
            float(text)
        except ValueError:
            return text
        return f"{text}%"

    def to_dict(self) -> dict:
        return {
            "product_id": str(self.prizeId),
            "name": self.name,
            "price": self.price,
            "remain_text": self._remain_percent_text(self.remainText),
            "remain_percent": self.remainText,
            "stock": self.stock,
            "score": self.score,
            "icon": self.icon,
            "prize_type": self.prizeType,
            "category_id": self.categoryId,
            "total_remain": self.totalRemain,
            "raw_order": self.rawOrder,
            "start_time": self.startTime,
            "end_time": self.endTime,
        }


class ActPrizeTag(TafStruct):
    """活动商品分类。"""

    def __init__(self):
        self.tagId: int = 0
        self.name: str = ""
        self.sort: int = 0

    def read_from(self, ins: TafInputStream):
        self.tagId = ins.read_int64(0, default=self.tagId)
        self.name = ins.read_string(1, default=self.name)
        self.sort = ins.read_int32(2, default=self.sort)

    def write_to(self, os: TafOutputStream):
        os.write_int64(0, self.tagId)
        os.write_string(1, self.name)
        os.write_int32(2, self.sort)

    @staticmethod
    def read_list_item(ins: TafInputStream, _tag: int):
        item = ActPrizeTag()
        item.read_from(ins)
        while True:
            _end_tag, dtype = ins.read_head()
            if dtype == TafType.STRUCT_END:
                break
            ins.skip_field(dtype)
        return item

    def to_dict(self) -> dict:
        return {
            "category_id": str(self.tagId),
            "category_name": self.name,
            "sort": self.sort,
        }


class GetActPrizeListResp(TafStruct):
    """webActUI.getActPrizeList 响应。"""

    def __init__(self):
        self.status: int = 0
        self.msg: str = ""
        self.prizes: list[ActPrizeItem] = []
        self.tags: list[ActPrizeTag] = []

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)
        self.prizes = ins.read_list(2, item_reader=ActPrizeItem.read_list_item)
        self.tags = ins.read_list(4, item_reader=ActPrizeTag.read_list_item)

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.status)
        os.write_string(1, self.msg)
        os.write_list(2, self.prizes)
        os.write_list(4, self.tags)

    def to_dict(self) -> dict:
        tag_info = {
            str(item.tagId): {"name": item.name, "sort": index, "raw_sort": item.sort}
            for index, item in enumerate(self.tags)
        }
        goods = []
        for item in self.prizes:
            data = item.to_dict()
            category = tag_info.get(data["category_id"], {})
            data["category_name"] = category.get("name", "")
            data["category_sort"] = category.get("sort", 0)
            goods.append(data)
        return {
            "status": self.status,
            "msg": self.msg,
            "goods_count": len(self.prizes),
            "categories": [item.to_dict() for item in self.tags],
            "goods": goods,
        }


class GameAccount(TafStruct):
    """游戏账号信息。"""

    def __init__(self):
        self.openId: str = ""
        self.appId: str = ""
        self.type: str = ""
        self.faceUrl: str = ""
        self.nick: str = ""
        self.accessToken: str = ""
        self.extendInfo: str = ""

    def read_from(self, ins: TafInputStream):
        self.openId = ins.read_string(0, default=self.openId)
        self.appId = ins.read_string(1, default=self.appId)
        self.type = ins.read_string(2, default=self.type)
        self.faceUrl = ins.read_string(3, default=self.faceUrl)
        self.nick = ins.read_string(4, default=self.nick)
        self.accessToken = ins.read_string(5, default=self.accessToken)
        self.extendInfo = ins.read_string(6, default=self.extendInfo)

    def write_to(self, os: TafOutputStream):
        os.write_string(0, self.openId)
        os.write_string(1, self.appId)
        os.write_string(2, self.type)
        os.write_string(3, self.faceUrl)
        os.write_string(4, self.nick)
        os.write_string(5, self.accessToken)
        os.write_string(6, self.extendInfo)

    def to_dict(self) -> dict:
        return {
            "app_id": self.appId,
            "type": self.type,
            "face_url": self.faceUrl,
            "nick": self.nick,
            "extend_info": self.extendInfo,
            "has_open_id": bool(self.openId),
            "has_access_token": bool(self.accessToken),
        }


class GameRole(TafStruct):
    """游戏角色信息。"""

    def __init__(self):
        self.roleId: str = ""
        self.roleName: str = ""
        self.areaName: str = ""
        self.platName: str = ""
        self.partitionName: str = ""
        self.gameSerial: str = ""
        self.extendInfo: str = ""

    def read_from(self, ins: TafInputStream):
        self.roleId = ins.read_string(0, default=self.roleId)
        self.roleName = ins.read_string(1, default=self.roleName)
        self.areaName = ins.read_string(2, default=self.areaName)
        self.platName = ins.read_string(3, default=self.platName)
        self.partitionName = ins.read_string(4, default=self.partitionName)
        self.gameSerial = ins.read_string(5, default=self.gameSerial)
        self.extendInfo = ins.read_string(6, default=self.extendInfo)

    def write_to(self, os: TafOutputStream):
        os.write_string(0, self.roleId)
        os.write_string(1, self.roleName)
        os.write_string(2, self.areaName)
        os.write_string(3, self.platName)
        os.write_string(4, self.partitionName)
        os.write_string(5, self.gameSerial)
        os.write_string(6, self.extendInfo)

    def to_dict(self) -> dict:
        return {
            "role_id": self.roleId,
            "role_name": self.roleName,
            "area_name": self.areaName,
            "plat_name": self.platName,
            "partition_name": self.partitionName,
            "game_serial": self.gameSerial,
            "extend_info": self.extendInfo,
        }


class GameAccountData(TafStruct):
    """绑定账号状态。"""

    def __init__(self):
        self.isBindAcount: int = 0
        self.isBindRole: int = 0
        self.isNeedActCheck: int = 0
        self.gameAccount = GameAccount()
        self.gameRole = GameRole()
        self.changBindTime: int = 0

    def read_from(self, ins: TafInputStream):
        self.isBindAcount = ins.read_int32(0, default=self.isBindAcount)
        self.isBindRole = ins.read_int32(1, default=self.isBindRole)
        self.isNeedActCheck = ins.read_int32(2, default=self.isNeedActCheck)
        self.gameAccount = ins.read_struct(3, GameAccount) or self.gameAccount
        self.gameRole = ins.read_struct(4, GameRole) or self.gameRole
        self.changBindTime = ins.read_int32(5, default=self.changBindTime)

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.isBindAcount)
        os.write_int32(1, self.isBindRole)
        os.write_int32(2, self.isNeedActCheck)
        os.write_struct(3, self.gameAccount)
        os.write_struct(4, self.gameRole)
        os.write_int32(5, self.changBindTime)

    def to_dict(self) -> dict:
        return {
            "is_bind_account": self.isBindAcount,
            "is_bind_role": self.isBindRole,
            "is_need_act_check": self.isNeedActCheck,
            "game_account": self.gameAccount.to_dict(),
            "game_role": self.gameRole.to_dict(),
            "change_bind_time": self.changBindTime,
        }


class CheckUserBindGameAccountReq(TafStruct):
    """webActUI.checkUserBindGameAccount 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.gid: int = 0
        self.outerActId: str = ""
        self.isInnerBind: int = 0
        self.scene: str = ""
        self.bActId: int = 0
        self.isUseOuterActId: int = 0

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_int32(1, self.gid)
        os.write_string(2, self.outerActId)
        os.write_int32(3, self.isInnerBind)
        os.write_string(4, self.scene)
        os.write_int32(5, self.bActId)
        os.write_int32(6, self.isUseOuterActId)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.gid = ins.read_int32(1, default=self.gid)
        self.outerActId = ins.read_string(2, default=self.outerActId)
        self.isInnerBind = ins.read_int32(3, default=self.isInnerBind)
        self.scene = ins.read_string(4, default=self.scene)
        self.bActId = ins.read_int32(5, default=self.bActId)
        self.isUseOuterActId = ins.read_int32(6, default=self.isUseOuterActId)


class CheckUserBindGameAccountResp(TafStruct):
    """webActUI.checkUserBindGameAccount 响应。"""

    def __init__(self):
        self.status: int = 0
        self.msg: str = ""
        self.accountData = GameAccountData()
        self.gameName: str = ""
        self.gameAuthScene: str = ""
        self.changeBindDay: int = 0

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)
        self.accountData = ins.read_struct(2, GameAccountData) or self.accountData
        self.gameName = ins.read_string(3, default=self.gameName)
        self.gameAuthScene = ins.read_string(4, default=self.gameAuthScene)
        self.changeBindDay = ins.read_int32(5, default=self.changeBindDay)

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.status)
        os.write_string(1, self.msg)
        os.write_struct(2, self.accountData)
        os.write_string(3, self.gameName)
        os.write_string(4, self.gameAuthScene)
        os.write_int32(5, self.changeBindDay)

    def to_dict(self) -> dict:
        return {
            "status": self.status,
            "msg": self.msg,
            "account_data": self.accountData.to_dict(),
            "game_name": self.gameName,
            "game_auth_scene": self.gameAuthScene,
            "change_bind_day": self.changeBindDay,
        }


class ConfirmBindActAccountReq(TafStruct):
    """webActUI.confirmBindActAccount 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.gid: int = 0
        self.outerActId: str = ""
        self.bActId: int = 0

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_int32(1, self.gid)
        os.write_string(2, self.outerActId)
        os.write_int32(3, self.bActId)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.gid = ins.read_int32(1, default=self.gid)
        self.outerActId = ins.read_string(2, default=self.outerActId)
        self.bActId = ins.read_int32(3, default=self.bActId)


class ConfirmBindActAccountResp(TafStruct):
    """webActUI.confirmBindActAccount 响应。"""

    def __init__(self):
        self.status: int = 0
        self.msg: str = ""

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.status)
        os.write_string(1, self.msg)

    def to_dict(self) -> dict:
        return {
            "status": self.status,
            "msg": self.msg,
        }


class GetLiveLinkParamReq(TafStruct):
    """webActUI.getLiveLinkParam 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.gid: int = 0
        self.outerActId: int = 0
        self.gameAuthScene: str = ""
        self.v: str = ""
        self.bActId: int = 0

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_int32(1, self.gid)
        os.write_int32(2, self.outerActId)
        os.write_string(3, self.gameAuthScene)
        os.write_string(4, self.v)
        os.write_int32(5, self.bActId)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.gid = ins.read_int32(1, default=self.gid)
        self.outerActId = ins.read_int32(2, default=self.outerActId)
        self.gameAuthScene = ins.read_string(3, default=self.gameAuthScene)
        self.v = ins.read_string(4, default=self.v)
        self.bActId = ins.read_int32(5, default=self.bActId)


class GetLiveLinkParamResp(TafStruct):
    """webActUI.getLiveLinkParam 响应。"""

    def __init__(self):
        self.status: int = 0
        self.msg: str = ""
        self.livelinkParam: dict[str, str] = {}

    def read_from(self, ins: TafInputStream):
        self.status = ins.read_int32(0, default=self.status)
        self.msg = ins.read_string(1, default=self.msg)
        self.livelinkParam = ins.read_map(2)

    def write_to(self, os: TafOutputStream):
        os.write_int32(0, self.status)
        os.write_string(1, self.msg)
        os.write_map(2, self.livelinkParam)

    def to_dict(self) -> dict:
        return {
            "status": self.status,
            "msg": self.msg,
            "livelink_param": dict(self.livelinkParam),
        }

    def to_log_dict(self) -> dict:
        data = dict(self.livelinkParam)
        if data.get("code"):
            data["code"] = f"<redacted len={len(data['code'])}>"
        if data.get("sig"):
            data["sig"] = f"<redacted len={len(data['sig'])}>"
        return {
            "status": self.status,
            "msg": self.msg,
            "livelink_param": data,
        }


class GetUserProfileBatchReq(TafStruct):
    """huyauserui.getUserProfileBatch 请求。"""

    def __init__(self):
        self.userId = ActivityUserId()
        self.uidList: list[int] = []

    def write_to(self, os: TafOutputStream):
        os.write_struct(0, self.userId)
        os.write_list(1, self.uidList)

    def read_from(self, ins: TafInputStream):
        self.userId = ins.read_struct(0, ActivityUserId) or self.userId
        self.uidList = ins.read_list(1)


class HuyaUserProfile(TafStruct):
    """虎牙用户资料，仅读取绑定链接需要的字段。"""

    def __init__(self):
        self.uid: int = 0
        self.nick: str = ""
        self.avatar: str = ""
        self.passport: str = ""

    def read_from(self, ins: TafInputStream):
        while True:
            tag, dtype = ins.peek_head()
            if dtype == TafType.STRUCT_END:
                break
            ins.read_head()
            if tag == 0:
                self.uid = ins._read_int_value(dtype)
            elif tag == 1:
                self.nick = self._read_string_value(ins, dtype)
            elif tag == 2:
                self.avatar = self._read_string_value(ins, dtype)
            elif tag == 17:
                self.passport = self._read_string_value(ins, dtype)
            else:
                ins.skip_field(dtype)

    @staticmethod
    def _read_string_value(ins: TafInputStream, dtype: int) -> str:
        if dtype == TafType.STRING1:
            length = int.from_bytes(ins.buf.read(1), "big")
        elif dtype == TafType.STRING4:
            length = int.from_bytes(ins.buf.read(4), "big")
        else:
            ins.skip_field(dtype)
            return ""
        return ins.buf.read(length).decode("utf-8", errors="replace")

    def write_to(self, os: TafOutputStream):
        os.write_int64(0, self.uid)
        os.write_string(1, self.nick)
        os.write_string(2, self.avatar)
        os.write_string(17, self.passport)

    def to_dict(self) -> dict:
        return {
            "uid": self.uid,
            "nick": self.nick,
            "avatar": self.avatar,
            "passport": self.passport,
        }


class GetUserProfileBatchResp(TafStruct):
    """huyauserui.getUserProfileBatch 响应。"""

    def __init__(self):
        self.profiles: list[HuyaUserProfile] = []

    def read_from(self, ins: TafInputStream):
        found = ins._find_tag(0, False)
        if not found:
            return
        if found[1] != TafType.LIST:
            ins.skip_field(found[1])
            return
        count = ins._read_int_len()
        profiles = []
        for _ in range(count):
            _, dtype = ins.read_head()
            if dtype != TafType.STRUCT_BEGIN:
                ins.skip_field(dtype)
                continue
            item_profile = None
            while True:
                tag, field_type = ins.peek_head()
                if field_type == TafType.STRUCT_END:
                    ins.read_head()
                    break
                if tag == 0 and field_type == TafType.STRUCT_BEGIN:
                    item_profile = ins.read_struct(0, HuyaUserProfile)
                else:
                    ins.read_head()
                    ins.skip_field(field_type)
            if item_profile is not None:
                profiles.append(item_profile)
        self.profiles = profiles

    def write_to(self, os: TafOutputStream):
        os.write_list(0, self.profiles)

    def to_dict(self) -> dict:
        return {"profiles": [profile.to_dict() for profile in self.profiles]}


def _self_check():
    rsp = GetUserScoreResp()
    rsp.status = 200
    rsp.msg = "请求成功"
    rsp.gainScore = 300
    rsp.usedScore = 120
    rsp.newGainScore = 300
    rsp.newUsedScore = 120
    rsp.score = 180

    os = TafOutputStream()
    os.write_struct(0, rsp)
    ins = TafInputStream(os.get_bytes())
    _, dtype = ins.read_head()
    assert dtype == TafType.STRUCT_BEGIN

    parsed = GetUserScoreResp()
    parsed.read_from(ins)
    assert parsed.status == 200
    assert parsed.available_score == 180

    prize_rsp = GetActPrizeListResp()
    prize = ActPrizeItem()
    prize.prizeId = 12885
    prize.name = "赤蝎幽灵大礼包"
    prize.price = 3600
    prize.remainText = "39"
    prize.categoryId = "85"
    tag = ActPrizeTag()
    tag.tagId = 85
    tag.name = "限量返场"
    tag.sort = 2
    prize_rsp.status = 200
    prize_rsp.msg = "请求成功"
    prize_rsp.prizes = [prize]
    prize_rsp.tags = [tag]
    os = TafOutputStream()
    os.write_struct(0, prize_rsp)
    ins = TafInputStream(os.get_bytes())
    _, dtype = ins.read_head()
    assert dtype == TafType.STRUCT_BEGIN
    parsed_prize = GetActPrizeListResp()
    parsed_prize.read_from(ins)
    assert parsed_prize.status == 200
    assert parsed_prize.prizes[0].name == "赤蝎幽灵大礼包"
    assert parsed_prize.prizes[0].price == 3600
    parsed_prize_data = parsed_prize.to_dict()
    assert parsed_prize_data["goods"][0]["category_name"] == "限量返场"
    assert parsed_prize_data["goods"][0]["remain_text"] == "39%"

    link_rsp = GetLiveLinkParamResp()
    link_rsp.status = 200
    link_rsp.livelinkParam = {
        "actId": "17096",
        "gameIdList": "cjm",
        "livePlatId": "huya",
        "code": "abc",
        "sig": "def",
        "t": "1783159287",
    }
    os = TafOutputStream()
    os.write_struct(0, link_rsp)
    ins = TafInputStream(os.get_bytes())
    _, dtype = ins.read_head()
    assert dtype == TafType.STRUCT_BEGIN
    parsed_link = GetLiveLinkParamResp()
    parsed_link.read_from(ins)
    assert parsed_link.status == 200
    assert parsed_link.livelinkParam["actId"] == "17096"

    confirm_rsp = ConfirmBindActAccountResp()
    confirm_rsp.status = 200
    confirm_rsp.msg = "请求成功"
    os = TafOutputStream()
    os.write_struct(0, confirm_rsp)
    ins = TafInputStream(os.get_bytes())
    _, dtype = ins.read_head()
    assert dtype == TafType.STRUCT_BEGIN
    parsed_confirm = ConfirmBindActAccountResp()
    parsed_confirm.read_from(ins)
    assert parsed_confirm.status == 200
    assert parsed_confirm.msg == "请求成功"


if __name__ == "__main__":
    _self_check()