import type { Client } from './client'
import { type Api, type UserItem, type UserMusicDetail } from './typings/api'
import { MusicDifficultyID } from './typings/api/base/MusicDifficultyID'
import { PlayComboFlagID } from './typings/api/base/PlayComboFlagID'
import { PlaySyncFlagID } from './typings/api/base/PlaySyncFlagID'
import { CardItem } from './typings/api/GetUserCardApi'
import { UserItemKind } from './typings/api/base/UserItem'
import { Playlog } from './typings/api/UploadUserPlaylogListApi'
import { LogoutType } from './typings/api/UserLogoutApi'
import { toLocalDateString, toLocalDateTimeString } from './utils/date'
import {
  CharacterSet,
  convertAchievementToScoreRank,
  ScoreEntry,
  ScoreSet,
  ItemSet,
  unpackPresent,
  Mission
} from './containers'
import { AwaitableEventEmitter, AwaitableEventMap } from './utils/event'

type RequestAllApi =
  | 'GetUserItemApi'
  | 'GetUserCardApi'
  | 'GetUserCourseApi'
  | 'GetUserMusicApi'
  | 'GetUserFavoriteItemApi'
  | 'GetUserMapApi'
  | 'GetUserLoginBonusApi'

export interface Present {
  [UserItemKind.Plate]: ItemSet
  [UserItemKind.Title]: ItemSet
  [UserItemKind.Icon]: ItemSet
  [UserItemKind.Music]: ItemSet
  [UserItemKind.Character]: ItemSet
  [UserItemKind.Partner]: ItemSet
  [UserItemKind.Frame]: ItemSet
  [UserItemKind.Ticket]: ItemSet
  // NOTE: 若 Present 的 itemId 经解析后指向 UserItemKind.Present, UserItemKind.MusicMas, UserItemKind.MusicRem, UserItemKind.MusicSrg 则会直接忽略此礼物。
}

export interface SaveEventMap extends AwaitableEventMap<void> {
  progress: [ProgressEvent]
}

export interface SaveProgress {
  loaded: number
  total: number
}

interface CacheMap {
  root?: {
    get data(): NonNullable<CacheMap['root.data']>
    get card(): NonNullable<CacheMap['root.card']>
    get character(): NonNullable<CacheMap['root.character']>
    get item(): NonNullable<CacheMap['root.item']>
    get course(): NonNullable<CacheMap['root.course']>
    get charge(): NonNullable<CacheMap['root.charge']>
    get favorite(): NonNullable<CacheMap['root.favorite']>
    get ghost(): NonNullable<CacheMap['root.ghost']>
    get map(): NonNullable<CacheMap['root.map']>
    get loginBonus(): NonNullable<CacheMap['root.loginBonus']>
    get region(): NonNullable<CacheMap['root.region']>
    get recommendRateMusic(): NonNullable<CacheMap['root.recommendRateMusic']>
    get recommendSelectMusic(): NonNullable<
      CacheMap['root.recommendSelectMusic']
    >
    get option(): NonNullable<CacheMap['root.option']>
    get extend(): NonNullable<CacheMap['root.extend']>
    get rating(): NonNullable<CacheMap['root.rating']>
    get score(): NonNullable<CacheMap['root.score']>
    get activity(): NonNullable<CacheMap['root.activity']>
    get mission(): NonNullable<CacheMap['root.mission']>
  }
  'root.item'?: {
    get [UserItemKind.Plate](): NonNullable<CacheMap['root.item.plate']>
    get [UserItemKind.Title](): NonNullable<CacheMap['root.item.title']>
    get [UserItemKind.Partner](): NonNullable<CacheMap['root.item.partner']>
    get [UserItemKind.Icon](): NonNullable<CacheMap['root.item.icon']>
    get [UserItemKind.Present](): NonNullable<CacheMap['root.item.present']>
    get [UserItemKind.Frame](): NonNullable<CacheMap['root.item.frame']>
    get [UserItemKind.Ticket](): NonNullable<CacheMap['root.item.ticket']>
    get [UserItemKind.Music](): NonNullable<CacheMap['root.item.music']>
    get [UserItemKind.MusicMas](): NonNullable<CacheMap['root.item.musicMas']>
    get [UserItemKind.MusicRem](): NonNullable<CacheMap['root.item.musicRem']>
    // get musicSrg(): NonNullable<CacheMap['root.item.musicSrg']>
  }
  'root.item.present'?: Promise<Present>
  'root.favorite'?: {
    get icon(): NonNullable<CacheMap['root.favorite.icon']>
    get plate(): NonNullable<CacheMap['root.favorite.plate']>
    get title(): NonNullable<CacheMap['root.favorite.title']>
    get character(): NonNullable<CacheMap['root.favorite.character']>
    get frame(): NonNullable<CacheMap['root.favorite.frame']>
    get music(): NonNullable<CacheMap['root.favorite.music']>
    get rival(): NonNullable<CacheMap['root.favorite.rival']>
  }
  'root.data'?: Promise<
    Api['GetUserDataApi'][1]['userData'] & { banState: number }
  >
  'root.card'?: Promise<{
    card: NonNullable<Api['GetUserCardApi'][1]['userCardList']>
    serialId: NonNullable<Api['GetUserCardApi'][1]['serialIdList']>
  }>
  'root.map'?: Promise<NonNullable<Api['GetUserMapApi'][1]['userMapList']>>
  // TODO: Watch Modification
  'root.character'?: Promise<CharacterSet>
  'root.item.plate'?: Promise<ItemSet>
  'root.item.title'?: Promise<ItemSet>
  'root.item.partner'?: Promise<ItemSet>
  'root.item.icon'?: Promise<ItemSet>
  'root.item.frame'?: Promise<ItemSet>
  'root.item.ticket'?: Promise<ItemSet>
  'root.item.music'?: Promise<ItemSet>
  'root.item.musicMas'?: Promise<ItemSet>
  'root.item.musicRem'?: Promise<ItemSet>
  // 'root.item.musicSrg'?: Promise<
  //   NonNullable<Api['GetUserItemApi'][1]['userItemList']>
  // >
  'root.ghost'?: Promise<Api['GetUserGhostApi'][1]['userGhostList']>
  'root.favorite.icon'?: Promise<
    Api['GetUserFavoriteApi'][1]['userFavorite']['itemIdList']
  >
  'root.favorite.plate'?: Promise<
    Api['GetUserFavoriteApi'][1]['userFavorite']['itemIdList']
  >
  'root.favorite.title'?: Promise<
    Api['GetUserFavoriteApi'][1]['userFavorite']['itemIdList']
  >
  'root.favorite.character'?: Promise<
    Api['GetUserFavoriteApi'][1]['userFavorite']['itemIdList']
  >
  'root.favorite.frame'?: Promise<
    Api['GetUserFavoriteApi'][1]['userFavorite']['itemIdList']
  >
  'root.favorite.music'?: Promise<
    NonNullable<Api['GetUserFavoriteItemApi'][1]['userFavoriteItemList']>
  >
  'root.favorite.rival'?: Promise<
    NonNullable<Api['GetUserFavoriteItemApi'][1]['userFavoriteItemList']>
  >
  'root.loginBonus'?: Promise<
    NonNullable<Api['GetUserLoginBonusApi'][1]['userLoginBonusList']>
  >
  'root.course'?: Promise<
    NonNullable<Api['GetUserCourseApi'][1]['userCourseList']>
  >
  'root.charge'?: Promise<
    NonNullable<Api['GetUserChargeApi'][1]['userChargeList']>
  >
  'root.score'?: Promise<ScoreSet>
  'root.score.reset'?: () => void
  'root.rating'?: Promise<Api['GetUserRatingApi'][1]['userRating']>
  'root.region'?: Promise<
    NonNullable<Api['GetUserRegionApi'][1]['userRegionList']>
  >
  'root.recommendRateMusic'?: Promise<
    Api['GetUserRecommendRateMusicApi'][1]['userRecommendRateMusicIdList']
  >
  'root.recommendSelectMusic'?: Promise<
    Api['GetUserRecommendSelectMusicApi'][1]['userRecommendSelectionMusicIdList']
  >
  'root.option'?: Promise<Api['GetUserOptionApi'][1]['userOption']>
  'root.extend'?: Promise<Api['GetUserExtendApi'][1]['userExtend']>
  'root.activity'?: Promise<Api['GetUserActivityApi'][1]['userActivity']>
  'root.mission'?: Promise<Mission>
}

export type PlaylogInit = Partial<Playlog> & {
  musicId: number
  level: MusicDifficultyID
  achievement: number
  tapCriticalPerfect: number
  tapPerfect: number
  tapGreat: number
  tapGood: number
  tapMiss: number
  holdCriticalPerfect: number
  holdPerfect: number
  holdGreat: number
  holdGood: number
  holdMiss: number
  slideCriticalPerfect: number
  slidePerfect: number
  slideGreat: number
  slideGood: number
  slideMiss: number
  touchCriticalPerfect: number
  touchPerfect: number
  touchGreat: number
  touchGood: number
  touchMiss: number
  breakCriticalPerfect: number
  breakPerfect: number
  breakGreat: number
  breakGood: number
  breakMiss: number
  fastCount: number
  lateCount: number
  isCriticalDisp: boolean
  comboStatus: PlayComboFlagID
  syncStatus: PlaySyncFlagID
  maxCombo: number
}

export function calculateDeluxscore(playlog: PlaylogInit) {
  const tapDx =
    playlog.tapCriticalPerfect * 3 + playlog.tapPerfect * 2 + playlog.tapGreat
  const holdDx =
    playlog.holdCriticalPerfect * 3 +
    playlog.holdPerfect * 2 +
    playlog.holdGreat
  const slideDx =
    playlog.slideCriticalPerfect * 3 +
    playlog.slidePerfect * 2 +
    playlog.slideGreat
  const touchDx =
    playlog.touchCriticalPerfect * 3 +
    playlog.touchPerfect * 2 +
    playlog.touchGreat
  const breakDx =
    playlog.breakCriticalPerfect * 3 +
    playlog.breakPerfect * 2 +
    playlog.breakGreat
  return tapDx + holdDx + slideDx + touchDx + breakDx
}

export function splitPresent(data: UserItem[]): Present {
  const present: Map<UserItemKind, UserItem[]> = new Map([
    [UserItemKind.Plate, []],
    [UserItemKind.Title, []],
    [UserItemKind.Icon, []],
    [UserItemKind.Music, []],
    [UserItemKind.Character, []],
    [UserItemKind.Partner, []],
    [UserItemKind.Frame, []],
    [UserItemKind.Ticket, []]
  ])
  for (const item of data) {
    if (item.itemKind === UserItemKind.Present && item.isValid) {
      const [kind, id] = unpackPresent(item.itemId)
      if (present.has(kind)) {
        present.get(kind)?.push({
          itemKind: kind,
          itemId: id,
          stock: item.stock,
          isValid: item.isValid
        })
      }
    }
  }
  return {
    [UserItemKind.Plate]: new ItemSet(
      present.get(UserItemKind.Plate) ?? [],
      UserItemKind.Plate,
      true
    ),
    [UserItemKind.Title]: new ItemSet(
      present.get(UserItemKind.Title) ?? [],
      UserItemKind.Title,
      true
    ),
    [UserItemKind.Icon]: new ItemSet(
      present.get(UserItemKind.Icon) ?? [],
      UserItemKind.Icon,
      true
    ),
    [UserItemKind.Music]: new ItemSet(
      present.get(UserItemKind.Music) ?? [],
      UserItemKind.Music,
      true
    ),
    [UserItemKind.Character]: new ItemSet(
      present.get(UserItemKind.Character) ?? [],
      UserItemKind.Character,
      true
    ),
    [UserItemKind.Partner]: new ItemSet(
      present.get(UserItemKind.Partner) ?? [],
      UserItemKind.Partner,
      true
    ),
    [UserItemKind.Frame]: new ItemSet(
      present.get(UserItemKind.Frame) ?? [],
      UserItemKind.Frame,
      true
    ),
    [UserItemKind.Ticket]: new ItemSet(
      present.get(UserItemKind.Ticket) ?? [],
      UserItemKind.Ticket,
      true
    )
  }
}

export class User {
  private _cache: CacheMap = {}
  constructor(
    public id: number,
    public loginId: bigint | null,
    public dateTime: Date | null,
    public client: Client,
    public isLogin: boolean,
    public loginDateTime: Date,
    public token: string = ''
  ) { }

  private _useCache<T extends keyof CacheMap>(
    key: T,
    fn: () => NonNullable<CacheMap[T]>
  ) {
    if (this._cache[key]) {
      return this._cache[key]
    }
    const result = fn()
    this._cache[key] = result
    return result
  }

  private _queryCache<T extends keyof CacheMap>(
    key: T
  ): CacheMap[T] | undefined {
    return this._cache[key]
  }

  get data() {
    // 被 sbga 大粪代码气笑了
    const requestAll = async <T extends keyof Api & RequestAllApi>(
      apiName: T,
      data: Api[T][0]
    ): Promise<Api[T][1][]> => {
      const result: Api[T][1][] = []
      let index = 0n
      while (true) {
        const resp = (await this.client.request(
          apiName,
          Object.assign({}, data, {
            nextIndex:
              index === 0n
                ? BigInt(
                  (data as { nextIndex?: number | bigint }).nextIndex ?? 0n
                )
                : index
          }),
          {
            userId: this.id
          }
        )) as Api[T][1] & {
          nextIndex: number | bigint
        }
        result.push(resp)
        index = BigInt(resp.nextIndex)
        if (index === 0n) break
      }
      return result
    }
    const getItem = async (kind: UserItemKind) => {
      return (
        await requestAll('GetUserItemApi', {
          userId: this.id,
          nextIndex: BigInt(kind) * 10000000000n,
          maxCount: 100
        })
      )
        .map(v => v.userItemList ?? [])
        .flat()
    }
    const getFavorite = async (
      kind: number
    ): Promise<Api['GetUserFavoriteApi'][1]['userFavorite']['itemIdList']> => {
      return (
        await this.client.request(
          'GetUserFavoriteApi',
          {
            userId: this.id,
            itemKind: kind
          },
          {
            userId: this.id
          }
        )
      ).userFavorite.itemIdList
    }
    const getFavoriteItem = async (kind: UserItemKind) => {
      return (
        await requestAll('GetUserFavoriteItemApi', {
          userId: this.id,
          kind,
          isAllFavoriteItem: false,
          nextIndex: 0n,
          maxCount: 100
        })
      )
        .map(v => v.userFavoriteItemList ?? [])
        .flat()
    }
    /* eslint-disable-next-line @typescript-eslint/no-this-alias */
    const self = this
    return this._useCache('root', () => ({
      get data() {
        return self._useCache('root.data', async () => {
          const res = await self.client.request(
            'GetUserDataApi',
            {
              userId: self.id
            },
            { userId: self.id }
          )
          if (res === null) throw new Error('User data is null')
          const result = {
            ...res.userData,
            banState: res.banState
          }
          const obj = result as unknown as Record<string, unknown>
          delete obj['friendCode']
          delete obj['nameplateId']
          delete obj['cmLastEmoneyBrand']
          delete obj['trophyId']
          delete obj['cmLastEmoneyCredit']
          return result
        })
      },
      get card() {
        return self._useCache(
          'root.card',
          async () =>
            (
              await requestAll('GetUserCardApi', {
                userId: self.id,
                nextIndex: 0,
                maxCount: 10000
              })
            )
              .map(v => [v.userCardList ?? [], v.serialIdList ?? []] as const)
              .reduce((previous, current) => {
                if (Array.isArray(previous)) {
                  return {
                    card: [...previous[0], ...current[0]],
                    serialId: [...previous[1], ...current[1]]
                  } as unknown as readonly [CardItem[], unknown[]]
                } else {
                  const p = previous as unknown as {
                    card: CardItem[]
                    serialId: unknown[]
                  }
                  p.card.push(...current[0])
                  p.serialId.push(...current[1])
                  return previous
                }
              }) as unknown as {
                card: CardItem[]
                serialId: unknown[]
              }
        )
      },
      get character() {
        return self._useCache(
          'root.character',
          async () =>
            new CharacterSet(
              (
                await self.client.request(
                  'GetUserCharacterApi',
                  {
                    userId: self.id
                  },
                  { userId: self.id }
                )
              ).userCharacterList ?? []
            ) // TODO: Character Instance
        )
      },
      get item() {
        return self._useCache('root.item', () => ({
          get [UserItemKind.Plate]() {
            return self._useCache(
              'root.item.plate',
              async () =>
                new ItemSet(
                  await getItem(UserItemKind.Plate),
                  UserItemKind.Plate,
                  false
                )
            )
          },
          get [UserItemKind.Title]() {
            return self._useCache(
              'root.item.title',
              async () =>
                new ItemSet(
                  await getItem(UserItemKind.Title),
                  UserItemKind.Title,
                  false
                )
            )
          },
          get [UserItemKind.Partner]() {
            return self._useCache(
              'root.item.partner',
              async () =>
                new ItemSet(
                  await getItem(UserItemKind.Partner),
                  UserItemKind.Partner,
                  false
                )
            )
          },
          get [UserItemKind.Icon]() {
            return self._useCache(
              'root.item.icon',
              async () =>
                new ItemSet(
                  await getItem(UserItemKind.Icon),
                  UserItemKind.Icon,
                  false
                )
            )
          },
          get [UserItemKind.Present]() {
            return self._useCache('root.item.present', async () =>
              splitPresent(await getItem(UserItemKind.Present))
            )
          },
          get [UserItemKind.Frame]() {
            return self._useCache(
              'root.item.frame',
              async () =>
                new ItemSet(
                  await getItem(UserItemKind.Frame),
                  UserItemKind.Frame,
                  false
                )
            )
          },
          get [UserItemKind.Ticket]() {
            return self._useCache(
              'root.item.ticket',
              async () =>
                new ItemSet(
                  await getItem(UserItemKind.Ticket),
                  UserItemKind.Ticket,
                  false
                )
            )
          },
          get [UserItemKind.Music]() {
            return self._useCache(
              'root.item.music',
              async () =>
                new ItemSet(
                  await getItem(UserItemKind.Music),
                  UserItemKind.Music,
                  false
                )
            )
          },
          get [UserItemKind.MusicMas]() {
            return self._useCache(
              'root.item.musicMas',
              async () =>
                new ItemSet(
                  await getItem(UserItemKind.MusicMas),
                  UserItemKind.MusicMas,
                  false
                )
            )
          },
          get [UserItemKind.MusicRem]() {
            return self._useCache(
              'root.item.musicRem',
              async () =>
                new ItemSet(
                  await getItem(UserItemKind.MusicRem),
                  UserItemKind.MusicRem,
                  false
                )
            )
          }
          // get musicSrg() {
          //   return self._useCache('root.item.musicSrg', () =>
          //     getItem(UserItemKind.MusicSrg)
          //   )
          // },
        }))
      },
      get course() {
        return self._useCache('root.course', async () =>
          (
            await requestAll('GetUserCourseApi', {
              userId: self.id,
              nextIndex: 0n
            })
          )
            .map(v => v.userCourseList ?? [])
            .flat()
        )
      },
      get charge() {
        return self._useCache(
          'root.charge',
          async () =>
            (
              await self.client.request(
                'GetUserChargeApi',
                {
                  userId: self.id
                },
                { userId: self.id }
              )
            ).userChargeList ?? []
        )
      },
      get favorite() {
        return self._useCache('root.favorite', () => ({
          get icon() {
            return self._useCache('root.favorite.icon', () => getFavorite(1))
          },
          get plate() {
            return self._useCache('root.favorite.plate', () => getFavorite(2))
          },
          get title() {
            return self._useCache('root.favorite.title', () => getFavorite(3))
          },
          get character() {
            return self._useCache('root.favorite.character', () =>
              getFavorite(4)
            )
          },
          get frame() {
            return self._useCache('root.favorite.frame', () => getFavorite(5))
          },
          get music() {
            return self._useCache('root.favorite.music', () =>
              getFavoriteItem(1)
            )
          },
          get rival() {
            return self._useCache('root.favorite.rival', () =>
              getFavoriteItem(2)
            )
          }
        }))
      },
      get ghost() {
        return self._useCache(
          'root.ghost',
          async () =>
            (
              await self.client.request(
                'GetUserGhostApi',
                {
                  userId: self.id
                },
                { userId: self.id }
              )
            ).userGhostList // TODO: Ghost Instance
        )
      },
      get map() {
        return self._useCache('root.map', async () =>
          (
            await requestAll('GetUserMapApi', {
              userId: self.id,
              nextIndex: 0n,
              maxCount: 10000
            })
          )
            .map(v => v.userMapList ?? [])
            .flat()
        )
      },
      get loginBonus() {
        return self._useCache('root.loginBonus', async () =>
          (
            await requestAll('GetUserLoginBonusApi', {
              userId: self.id,
              nextIndex: 0n,
              maxCount: 10000
            })
          )
            .map(v => v.userLoginBonusList ?? [])
            .flat()
        )
      },
      get region() {
        return self._useCache(
          'root.region',
          async () =>
            (
              await self.client.request(
                'GetUserRegionApi',
                {
                  userId: self.id
                },
                { userId: self.id }
              )
            ).userRegionList ?? []
        )
      },
      get recommendRateMusic() {
        return self._useCache(
          'root.recommendRateMusic',
          async () =>
            (
              await self.client.request(
                'GetUserRecommendRateMusicApi',
                {
                  userId: self.id
                },
                { userId: self.id }
              )
            ).userRecommendRateMusicIdList
        )
      },
      get recommendSelectMusic() {
        return self._useCache(
          'root.recommendSelectMusic',
          async () =>
            (
              await self.client.request(
                'GetUserRecommendSelectMusicApi',
                {
                  userId: self.id
                },
                { userId: self.id }
              )
            ).userRecommendSelectionMusicIdList
        )
      },
      get option() {
        return self._useCache('root.option', async () => {
          const result = (
            await self.client.request(
              'GetUserOptionApi',
              {
                userId: self.id
              },
              { userId: self.id }
            )
          ).userOption
          const obj = result as unknown as Record<string, unknown>
          delete obj['tempoVolume']
          return result
        })
      },
      get extend() {
        return self._useCache(
          'root.extend',
          async () =>
            (
              await self.client.request(
                'GetUserExtendApi',
                {
                  userId: self.id
                },
                { userId: self.id }
              )
            ).userExtend
        )
      },
      get rating() {
        return self._useCache('root.rating', async () => {
          const result = (
            await self.client.request(
              'GetUserRatingApi',
              {
                userId: self.id
              },
              { userId: self.id }
            )
          ).userRating
          const obj = result.udemae as unknown as Record<string, unknown>
          delete obj['MaxLoseNum']
          delete obj['NpcLoseNum']
          delete obj['NpcMaxLoseNum']
          delete obj['NpcMaxWinNum']
          delete obj['NpcTotalLoseNum']
          delete obj['NpcTotalWinNum']
          delete obj['NpcWinNum']
          return result
        })
      },
      get score() {
        return self._useCache('root.score', async () => {
          const res = ScoreSet.resettable(
            (
              await requestAll('GetUserMusicApi', {
                userId: self.id,
                nextIndex: 0n,
                maxCount: 10000
              })
            )
              .map(v => v.userMusicList ?? [])
              .flat()
              .map(v => v.userMusicDetailList ?? [])
              .flat()
              .map(v => {
                const obj = v as unknown as Record<string, unknown>
                delete obj['extNum2']
                return v
              })
          )
          self._cache['root.score.reset'] = res[1]
          return res[0]
        })
      },
      get activity() {
        return self._useCache(
          'root.activity',
          async () =>
            (
              await self.client.request(
                'GetUserActivityApi',
                {
                  userId: self.id
                },
                { userId: self.id }
              )
            ).userActivity ?? {}
        )
      },
      get mission() {
        return self._useCache('root.mission', async () => {
          const result = await self.client.request(
            'GetUserMissionDataApi',
            {
              userId: self.id
            },
            { userId: self.id }
          )
          return new Mission(result.userWeeklyData, result.userMissionDataList)
        })
      }
    }))
  }

  async [Symbol.asyncDispose]() {
    if (this.isLogin) {
      await this.logout()
    }
  }

  async refresh() {
    if (this.isLogin) {
      await this.logout()
    }

    const newInstance = await this.client.login(this.id, this.token, {
      isContinue: true
    })
    this.isLogin = newInstance.isLogin
    this.loginId = newInstance.loginId
    this.token = newInstance.token
    this.loginDateTime = newInstance.loginDateTime
  }

  async charge(options: {
    kind: number
    stock: number
    price: number
    purchaseDate?: Date
    validDate?: Date
  }) {
    options.purchaseDate = options.purchaseDate ?? new Date()
    // validDate 默认为 purchaseDate + 90 天的凌晨4点
    options.validDate =
      options.validDate ??
      new Date(
        options.purchaseDate.getFullYear(),
        options.purchaseDate.getMonth(),
        options.purchaseDate.getDate() + 90,
        4,
        0,
        0,
        0
      )
    await this.client.request(
      'UpsertUserChargelogApi',
      {
        userId: this.id,
        userCharge: {
          chargeId: options.kind,
          stock: options.stock,
          purchaseDate: toLocalDateTimeString(options.purchaseDate),
          validDate: toLocalDateTimeString(options.validDate)
        },
        userChargelog: {
          chargeId: options.kind,
          clientId: this.client.shortChipId,
          regionId: this.client.place.region.id,
          placeId: this.client.place.id,
          price: options.price,
          purchaseDate: toLocalDateTimeString(options.purchaseDate)
        }
      },
      {
        userId: this.id
      }
    )
  }

  async logout(type = LogoutType.Logout) {
    if (!this.isLogin) {
      throw new Error('Unable to logout: User already logged out')
    }
    if (!this.loginDateTime) {
      throw new Error('Unable to logout: loginDateTime is null')
    }
    this.isLogin = false
    const timestamp = Math.floor(this.loginDateTime.getTime() / 1000)
    await this.client.request(
      'UserLogoutApi',
      {
        userId: this.id,
        accessCode: '',
        regionId: this.client.place.region.id,
        placeId: this.client.place.id,
        clientId: this.client.shortChipId,
        loginDateTime: timestamp,
        type
      },
      {
        userId: this.id
      }
    )
  }

  async update(options: {
    romVersion: string
    dataVersion: string
  }): Promise<void> {
    const data = await this.data.data
    data.lastRomVersion = options.romVersion
    data.lastDataVersion = options.dataVersion
  }

  /**
   * Saves the current user's state including play log, user data, character information,
   * and various game details to the backend.
   *
   * This asynchronous function aggregates new and existing play log data, generates additional
   * play logs if necessary, and prepares comprehensive user data by merging character details,
   * item lists, mission data, and various other game state information.
   *
   * The function performs the following main steps:
   * - Verifies that the user is logged in; throws an error if not.
   * - Generates random numbers and special values used in play logs.
   * - Constructs play log entries by merging pre-existing log entries with newly generated ones.
   * - Fetches and validates the user's selected characters, ensuring that necessary character
   *   information is retrieved or defaulted.
   * - Aggregates and organizes several parts of the user data, including scores, achievements,
   *   and other related information.
   * - Sequentially uploads each play log entry and then sends the complete user state update
   *   to the backend via client API requests.
   *
   * @param options - An optional object containing:
   *   - playlog: An array of play log entries (of types Playlog or PlaylogInit) to be used in the save.
   *   - eventMode: A boolean indicating if the event mode should be enabled.
   *   - freePlay: A boolean indicating if the free play mode should be enabled.
   *
   * @throws {Error} Throws if the user is not logged in correctly or if character information is
   * missing or invalid.
   *
   * @returns A Promise that resolves when the save process (including all API requests) has completed.
   */
  save(options?: {
    playlog?: (Playlog | PlaylogInit)[]
    eventMode?: boolean
    freePlay?: boolean
  }): AwaitableEventEmitter<void, SaveEventMap> {
    const emitter = AwaitableEventEmitter.fromAsync(async () => {
      const [
        data,
        character,
        score,
        option,
        extend,
        charge,
        mission,
        activity,
        rating
      ] = await Promise.all([
        this.data.data,
        this.data.character,
        this.data.score,
        this.data.option,
        this.data.extend,
        this.data.charge,
        this.data.mission,
        this.data.activity,
        this.data.rating
      ])
      const generatePlaySpecial = () => {
        // 生成一个 1 至 1037933 的随机整数
        let num = (Math.floor(Math.random() * 1037933) + 1) * 2069
        num += 1024 // += GameManager.CalcSpecialNum();
        let num2 = 0
        for (let i = 0; i < 32; i++) {
          num2 <<= 1
          num2 += num % 2
          num >>= 1
        }
        return num2
      }
      const generatePlaylog = (detail: UserMusicDetail) => {
        return {
          level: detail.level,
          achievement: 0,
          musicId: detail.musicId,
          tapCriticalPerfect: 0,
          tapPerfect: 0,
          tapGreat: 0,
          tapGood: 0,
          tapMiss: 1,
          holdCriticalPerfect: 0,
          holdPerfect: 0,
          holdGreat: 0,
          holdGood: 0,
          holdMiss: 0,
          slideCriticalPerfect: 0,
          slidePerfect: 0,
          slideGreat: 0,
          slideGood: 0,
          slideMiss: 0,
          touchCriticalPerfect: 0,
          touchPerfect: 0,
          touchGreat: 0,
          touchGood: 0,
          touchMiss: 0,
          breakCriticalPerfect: 0,
          breakPerfect: 0,
          breakGreat: 0,
          breakGood: 0,
          breakMiss: 0,
          fastCount: 0,
          lateCount: 0,
          isCriticalDisp: false,
          comboStatus: PlayComboFlagID.None,
          syncStatus: PlaySyncFlagID.None,
          maxCombo: 0,
          totalCombo: 0,
          maxSync: 0,
          totalSync: 0
        } satisfies PlaylogInit
      }
      interface CharacterData {
        characterId1: number
        characterAwakening1: number
        characterLevel1: number
        characterId2: number
        characterAwakening2: number
        characterLevel2: number
        characterId3: number
        characterAwakening3: number
        characterLevel3: number
        characterId4: number
        characterAwakening4: number
        characterLevel4: number
        characterId5: number
        characterAwakening5: number
        characterLevel5: number
      }
      const convertVersionNumber = (version: string): number => {
        // 1.41.00 -> 1041000
        const parts = version.split('.')
        if (parts.length !== 3) {
          throw new Error(`Invalid version format: ${version}`)
        }
        const major = parseInt(parts[0], 10)
        const minor = parseInt(parts[1], 10)
        const patch = parseInt(parts[2], 10)
        if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
          throw new Error(`Invalid version number: ${version}`)
        }
        return major * 1000000 + minor * 1000 + patch
      }
      const getUserSelectedCharacter = (
        option: Partial<CharacterData>
      ): CharacterData => {
        const raiseException = (message: string) => {
          throw new Error(message)
        }
        const final: CharacterData = {
          characterId1: 0,
          characterAwakening1: 0,
          characterLevel1: 0,
          characterId2: 0,
          characterAwakening2: 0,
          characterLevel2: 0,
          characterId3: 0,
          characterAwakening3: 0,
          characterLevel3: 0,
          characterId4: 0,
          characterAwakening4: 0,
          characterLevel4: 0,
          characterId5: 0,
          characterAwakening5: 0,
          characterLevel5: 0
        }
        for (let i = 0; i < 5; i++) {
          const originalId = option[
            `characterId${i + 1}` as keyof CharacterData
          ] as number | undefined
          const originalAwakening = option[
            `characterAwakening${i + 1}` as keyof CharacterData
          ] as number | undefined
          const originalLevel = option[
            `characterLevel${i + 1}` as keyof CharacterData
          ] as number | undefined
          if (originalId !== undefined) {
            Object.assign(final, {
              [`characterId${i + 1}` as keyof CharacterData]: originalId,
              [`characterAwakening${i + 1}` as keyof CharacterData]:
                originalAwakening ??
                character.get(originalId)?.awakening ??
                raiseException(`Character ${i + 1} not found`),
              [`characterLevel${i + 1}` as keyof CharacterData]:
                originalLevel ??
                character.get(originalId)?.level ??
                raiseException(`Character ${i + 1} not found`)
            })
          } else if (
            originalLevel !== undefined ||
            originalAwakening !== undefined
          ) {
            throw new Error(
              `Character ${i + 1} ID is required if level or awakening is set`
            )
          } else {
            const fill = character.get(data.charaSlot[i])
            if (!fill) throw new Error(`Character ${i + 1} not found`)
            Object.assign(final, {
              [`characterId${i + 1}` as keyof CharacterData]: data.charaSlot[i],
              [`characterAwakening${i + 1}` as keyof CharacterData]:
                fill.awakening,
              [`characterLevel${i + 1}` as keyof CharacterData]: fill.level
            })
          }
        }
        return final
      }
      if (!this.loginId || !this.dateTime)
        throw new Error('Not logged in correctly')
      // TODO: type hint

      let playlog: (Playlog | PlaylogInit)[] = options?.playlog ?? []
      const musicDetail = score.export()
      const generatedPlaylog = musicDetail
        .map(v => generatePlaylog(v.value))
        .filter(v => {
          return !playlog.some(
            v2 => v2.level === v.level && v2.musicId === v.musicId
          )
        }) satisfies PlaylogInit[]
      playlog = playlog.concat(generatedPlaylog)
      if (playlog.length === 0) {
        const ids = Array.from(score.keys())
        const randomId = ids[Math.floor(Math.random() * ids.length)]
        const entry = Object.entries(score.get(randomId)).find(([, v]) => {
          return !!v
        })
        if (!entry)
          throw new Error('At least one playlog is required for new user')
        const level = Number(entry[0]) as MusicDifficultyID
        const detail = entry[1] as ScoreEntry
        const generated: UserMusicDetail = {
          musicId: randomId,
          achievement: detail.achievement,
          comboStatus: detail.comboStatus,
          syncStatus: detail.syncStatus,
          deluxscoreMax: detail.deluxscoreMax,
          level,
          playCount: detail.playCount,
          scoreRank: detail.scoreRank,
          extNum1: detail.extNum1
        }
        musicDetail.push({ value: generated, isNew: false })
        playlog.push(generatePlaylog(generated))
      }
      const playlogList: Playlog[] = await Promise.all(
        Array.from(playlog.entries()).map(
          async ([index, log]) =>
            Object.assign(
              {},
              {
                userId: 0,
                orderId: 0,
                playlogId: this.loginId,
                version: convertVersionNumber(data.lastRomVersion),
                placeId: this.client.place.id,
                placeName: this.client.place.name,
                loginDate: Math.floor(this.dateTime!.getTime() / 1000),
                playDate: '',
                userPlayDate: '',
                type: 0,
                trackNo: (index % 4) + 1,
                vsMode: 0,
                vsStatus: 0,
                vsUserName: '',
                vsUserRating: 0,
                vsUserAchievement: 0,
                vsUserGradeRank: 0,
                vsRank: 0,
                playerNum: 1,
                playedUserId1: 0,
                playedUserName1: '',
                playedMusicLevel1: MusicDifficultyID.Basic,
                playedUserId2: 0,
                playedUserName2: '',
                playedMusicLevel2: MusicDifficultyID.Basic,
                playedUserId3: 0,
                playedUserName3: '',
                playedMusicLevel3: MusicDifficultyID.Basic,
                ...getUserSelectedCharacter(log),
                scoreRank: convertAchievementToScoreRank(
                  log.achievement,
                  log.achievement > 1010000 &&
                  log.level === MusicDifficultyID.Utage
                ), // TODO: utage
                isTap:
                  log.tapCriticalPerfect +
                  log.tapPerfect +
                  log.tapGreat +
                  log.tapGood +
                  log.tapMiss >
                  0,
                isHold:
                  log.holdCriticalPerfect +
                  log.holdPerfect +
                  log.holdGreat +
                  log.holdGood +
                  log.holdMiss >
                  0,
                isSlide:
                  log.slideCriticalPerfect +
                  log.slidePerfect +
                  log.slideGreat +
                  log.slideGood +
                  log.slideMiss >
                  0,
                isTouch:
                  log.touchCriticalPerfect +
                  log.touchPerfect +
                  log.touchGreat +
                  log.touchGood +
                  log.touchMiss >
                  0,
                isBreak:
                  log.breakCriticalPerfect +
                  log.breakPerfect +
                  log.breakGreat +
                  log.breakGood +
                  log.breakMiss >
                  0,
                isFastLateDisp: true,
                deluxscore: calculateDeluxscore(log as PlaylogInit),
                isAchieveNewRecord: false,
                isDeluxscoreNewRecord: false,
                isClear: log.achievement >= 500000,
                totalCombo:
                  log.tapCriticalPerfect +
                  log.tapPerfect +
                  log.tapGreat +
                  log.tapGood +
                  log.tapMiss +
                  (log.holdCriticalPerfect +
                    log.holdPerfect +
                    log.holdGreat +
                    log.holdGood +
                    log.holdMiss) +
                  (log.slideCriticalPerfect +
                    log.slidePerfect +
                    log.slideGreat +
                    log.slideGood +
                    log.slideMiss) +
                  (log.touchCriticalPerfect +
                    log.touchPerfect +
                    log.touchGreat +
                    log.touchGood +
                    log.touchMiss) +
                  (log.breakCriticalPerfect +
                    log.breakPerfect +
                    log.breakGreat +
                    log.breakGood +
                    log.breakMiss),
                maxSync:
                  log.tapCriticalPerfect +
                  log.tapPerfect +
                  log.tapGreat +
                  log.tapGood +
                  log.tapMiss +
                  (log.holdCriticalPerfect +
                    log.holdPerfect +
                    log.holdGreat +
                    log.holdGood +
                    log.holdMiss) +
                  (log.slideCriticalPerfect +
                    log.slidePerfect +
                    log.slideGreat +
                    log.slideGood +
                    log.slideMiss) +
                  (log.touchCriticalPerfect +
                    log.touchPerfect +
                    log.touchGreat +
                    log.touchGood +
                    log.touchMiss) +
                  (log.breakCriticalPerfect +
                    log.breakPerfect +
                    log.breakGreat +
                    log.breakGood +
                    log.breakMiss),
                totalSync: 0,
                beforeRating: log.beforeRating ?? data.playerRating,
                afterRating: log.afterRating ?? data.playerRating,
                beforeGrade: log.beforeGrade ?? data.gradeRating,
                afterGrade: log.afterGrade ?? data.gradeRating,
                afterGradeRank: log.afterGradeRank ?? data.gradeRank,
                beforeDeluxRating: log.beforeDeluxRating ?? data.playerRating,
                afterDeluxRating: log.afterDeluxRating ?? data.playerRating,
                isPlayTutorial: false,
                isEventMode: false,
                isFreedomMode: false,
                playMode: 0,
                isNewFree: false,
                trialPlayAchievement: -1,
                extNum1: 0,
                extNum2: 0,
                extNum4: 0,
                extBool1:
                  log.achievement > 1010000 &&
                  log.level === MusicDifficultyID.Utage, // NOTE: This is a workaround for Buddy charts (バディ譜面)
                extBool2: false
              },
              log
            ) satisfies Playlog
        )
      )
      const groupedPlaylogList = []
      const groupedMusicDetailList = []
      for (let i = 0; i < playlogList.length; i += 4) {
        groupedPlaylogList.push(playlogList.slice(i, i + 4))
        groupedMusicDetailList.push(musicDetail.slice(i, i + 4))
      }
      let lastPlayDate = new Date()
      // let lastPlayDate = new Date(
      //   fromLocalDateTimeString(data.lastPlayDate).getTime() + 1000
      // )
      for (let [index, group] of groupedPlaylogList.entries()) {
        if (index > 0) {
          const currentDate = new Date()
          if (currentDate.getTime() - lastPlayDate.getTime() < 1000) {
            await new Promise(resolve =>
              setTimeout(
                resolve,
                1100 - (currentDate.getTime() - lastPlayDate.getTime())
              )
            )
          }
          await this.refresh()
          lastPlayDate = new Date()
        }
        group = group.map(v =>
          Object.assign({}, v, {
            playlogId: this.loginId,
            playDate: toLocalDateString(lastPlayDate),
            userPlayDate: toLocalDateTimeString(lastPlayDate, true)
          })
        )
        if (index === 0) {
          await new Promise(resolve => setTimeout(resolve, 70000))
          await this.client.request('UpsertUserAllApi', {
            userId: this.id,
            playlogId: this.loginId,
            isEventMode: !!(options?.eventMode ?? false),
            isFreePlay: !!(options?.freePlay ?? false),
            loginDateTime: Math.floor(this.loginDateTime.getTime() / 1000),
            userPlaylogList: group,
            upsertUserAll: {
              userData: [
                Object.assign({}, data, {
                  dateTime: Math.floor(this.dateTime.getTime() / 1000),
                  lastGameId: this.client.codename,
                  lastPlaceId: this.client.place.id,
                  lastPlaceName: this.client.place.name,
                  lastRegionId: this.client.place.region.id,
                  lastRegionName: this.client.place.region.name[0],
                  lastClientId: this.client.shortChipId,
                  accessCode: '',
                  lastLoginDate: toLocalDateTimeString(this.dateTime, true), // TODO: compare
                  lastPlayDate: toLocalDateTimeString(lastPlayDate, true)
                } satisfies Partial<
                  Api['UpsertUserAllApi'][0]['upsertUserAll']['userData'][0]
                >) satisfies Api['UpsertUserAllApi'][0]['upsertUserAll']['userData'][0]
                // data
              ],
              userExtend: [extend],
              userOption: [option],
              ...(await (async () => {
                const character =
                  (await this._queryCache('root.character'))?.export() ?? []
                return {
                  userCharacterList: character.map(v => v.value),
                  isNewCharacterList: character
                    .map(v => (v.isNew ? '1' : '0'))
                    .join('')
                }
              })()),
              ...(await (async () => {
                const itemList = [
                  ...((await this._queryCache('root.item.plate'))?.export() ??
                    []),
                  ...((await this._queryCache('root.item.title'))?.export() ??
                    []),
                  ...((await this._queryCache('root.item.partner'))?.export() ??
                    []),
                  ...((await this._queryCache('root.item.icon'))?.export() ??
                    []),
                  ...((await this._queryCache('root.item.present'))?.[
                    UserItemKind.Plate
                  ]?.export() ?? []),
                  ...((await this._queryCache('root.item.present'))?.[
                    UserItemKind.Title
                  ]?.export() ?? []),
                  ...((await this._queryCache('root.item.present'))?.[
                    UserItemKind.Icon
                  ]?.export() ?? []),
                  ...((await this._queryCache('root.item.present'))?.[
                    UserItemKind.Music
                  ]?.export() ?? []),
                  ...((await this._queryCache('root.item.present'))?.[
                    UserItemKind.Character
                  ]?.export() ?? []),
                  ...((await this._queryCache('root.item.present'))?.[
                    UserItemKind.Partner
                  ]?.export() ?? []),
                  ...((await this._queryCache('root.item.present'))?.[
                    UserItemKind.Frame
                  ]?.export() ?? []),
                  ...((await this._queryCache('root.item.present'))?.[
                    UserItemKind.Ticket
                  ]?.export() ?? []),
                  ...((await this._queryCache('root.item.frame'))?.export() ??
                    []),
                  ...((await this._queryCache('root.item.ticket'))?.export() ??
                    []),
                  ...((await this._queryCache('root.item.music'))?.export() ??
                    []),
                  ...((
                    await this._queryCache('root.item.musicMas')
                  )?.export() ?? []),
                  ...((
                    await this._queryCache('root.item.musicRem')
                  )?.export() ?? [])
                ]
                return {
                  userItemList: itemList.map(v => v.value),
                  isNewItemList: itemList
                    .map(v => (v.isNew ? '1' : '0'))
                    .join('')
                }
              })()),
              userGhost: [], // TODO: lazy update
              userMapList: [], // TODO: lazy update
              userLoginBonusList: [], // TODO: lazy update
              userRatingList: [rating],
              ...(() => {
                return {
                  userMusicDetailList: groupedMusicDetailList[index].map(
                    v => v.value
                  ),
                  isNewMusicDetailList: groupedMusicDetailList[index]
                    .map(v => (v.isNew ? '1' : '0'))
                    .join('')
                }
              })(),
              userCourseList: [], // await this.data.course, // TODO: lazy update
              userFavoriteList: [], // TODO: lazy update
              userFriendSeasonRankingList: [], // TODO: lazy update
              userWeeklyData: mission.weekly,
              userMissionDataList: mission.mission,
              userIntimateList: [], // TODO: lazy update
              isNewUserIntimateList: '',
              userKaleidxScopeList: [], // TODO: lazy update
              isNewKaleidxScopeList: '',
              userShopItemStockList: [], // sega 程序员没有设置，故意的还是不小心的？
              userGetPointList: [], // TODO: lazy update
              userTradeItemList: [], // TODO: lazy update
              userFavoritemusicList: [], // TODO: lazy update
              isNewFavoritemusicList: '',
              userChargeList: charge.map(v => ({
                chargeId: v.chargeId,
                stock: v.stock,
                purchaseDate: v.purchaseDate,
                validDate: v.validDate
              })),
              userActivityList: [activity], // TODO: slice activity data & activity container
              userGamePlaylogList: [
                {
                  playlogId: this.loginId,
                  version: data.lastRomVersion,
                  playDate: toLocalDateTimeString(lastPlayDate, true),
                  playMode: 0,
                  useTicketId: -1,
                  playCredit: options?.freePlay ? 0 : 1,
                  playTrack: group.length,
                  clientId: this.client.shortChipId,
                  isPlayTutorial: false,
                  isEventMode: !!(options?.eventMode ?? false),
                  isNewFree: false,
                  playCount: 0,
                  playSpecial: generatePlaySpecial(),
                  playOtherUserId: 0
                }
              ],
              user2pPlaylog: {
                userId1: 0,
                userId2: 0,
                userName1: '',
                userName2: '',
                regionId: 0,
                placeId: 0,
                user2pPlaylogDetailList: []
              },
              // 对应的槽位变更: 0, 对应的槽位追加: 1
              // TODO: 根据变更计算字段
              isNewMapList: '',
              isNewLoginBonusList: '',
              isNewCourseList: '',
              isNewFavoriteList: '',
              isNewFriendSeasonRankingList: ''
            }
          } satisfies Api['UpsertUserAllApi'][0], {
            userId: this.id
          })
        } else {
          await new Promise(resolve => setTimeout(resolve, 70000))
          await this.client.request('UpsertUserAllApi', {
            userId: this.id,
            playlogId: this.loginId,
            isEventMode: !!(options?.eventMode ?? false),
            isFreePlay: !!(options?.freePlay ?? false),
            loginDateTime: Math.floor(this.loginDateTime.getTime() / 1000),
            userPlaylogList: group,
            upsertUserAll: {
              userData: [
                Object.assign({}, data, {
                  dateTime: Math.floor(this.dateTime.getTime() / 1000),
                  lastGameId: this.client.codename,
                  lastPlaceId: this.client.place.id,
                  lastPlaceName: this.client.place.name,
                  lastRegionId: this.client.place.region.id,
                  lastRegionName: this.client.place.region.name[0],
                  lastClientId: this.client.shortChipId,
                  accessCode: '',
                  lastLoginDate: toLocalDateTimeString(this.dateTime, true),
                  lastPlayDate: toLocalDateTimeString(lastPlayDate, true)
                } satisfies Partial<
                  Api['UpsertUserAllApi'][0]['upsertUserAll']['userData'][0]
                >) satisfies Api['UpsertUserAllApi'][0]['upsertUserAll']['userData'][0]
                // data
              ],
              userExtend: [extend],
              userOption: [option],
              userCharacterList: [],
              isNewCharacterList: '',
              userItemList: [],
              isNewItemList: '',
              userGhost: [],
              userMapList: [],
              userLoginBonusList: [],
              userRatingList: [rating],
              ...(() => {
                return {
                  userMusicDetailList: groupedMusicDetailList[index].map(
                    v => v.value
                  ),
                  isNewMusicDetailList: groupedMusicDetailList[index]
                    .map(v => (v.isNew ? '1' : '0'))
                    .join('')
                }
              })(),
              userCourseList: [],
              userFavoriteList: [],
              userFriendSeasonRankingList: [],
              userWeeklyData: mission.weekly,
              userMissionDataList: mission.mission,
              userIntimateList: [],
              isNewUserIntimateList: '',
              userKaleidxScopeList: [],
              isNewKaleidxScopeList: '',
              userShopItemStockList: [],
              userGetPointList: [],
              userTradeItemList: [],
              userFavoritemusicList: [],
              isNewFavoritemusicList: '',
              userChargeList: charge.map(v => ({
                chargeId: v.chargeId,
                stock: v.stock,
                purchaseDate: v.purchaseDate,
                validDate: v.validDate
              })),
              userActivityList: [activity],
              userGamePlaylogList: [
                {
                  playlogId: this.loginId,
                  version: data.lastRomVersion,
                  playDate: toLocalDateTimeString(lastPlayDate, true),
                  playMode: 0,
                  useTicketId: -1,
                  playCredit: options?.freePlay ? 0 : 1,
                  playTrack: group.length,
                  clientId: this.client.shortChipId,
                  isPlayTutorial: false,
                  isEventMode: !!(options?.eventMode ?? false),
                  isNewFree: false,
                  playCount: 0,
                  playSpecial: generatePlaySpecial(),
                  playOtherUserId: 0
                }
              ],
              user2pPlaylog: {
                userId1: 0,
                userId2: 0,
                userName1: '',
                userName2: '',
                regionId: 0,
                placeId: 0,
                user2pPlaylogDetailList: []
              },
              isNewMapList: '',
              isNewLoginBonusList: '',
              isNewCourseList: '',
              isNewFavoriteList: '',
              isNewFriendSeasonRankingList: ''
            }
          } satisfies Api['UpsertUserAllApi'][0], { userId: this.id })
        }
        emitter.emit('progress', {
          loaded: index + 1,
          total: groupedPlaylogList.length
        })
      }
      this._cache['root.score.reset']?.()
    })
    return emitter
  }
}