package com.gh.gamecenter.home

import android.content.Context
import android.view.View
import android.view.ViewGroup
import android.view.ViewGroup.MarginLayoutParams
import androidx.constraintlayout.widget.ConstraintLayout
import androidx.lifecycle.LifecycleOwner
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.gh.common.exposure.IExposable
import com.gh.common.util.DirectUtils
import com.gh.common.util.NewLogUtils
import com.gh.gamecenter.GameDetailActivity
import com.gh.gamecenter.R
import com.gh.gamecenter.adapter.viewholder.ReuseViewHolder
import com.gh.gamecenter.common.baselist.DiffUtilAdapter
import com.gh.gamecenter.common.baselist.LoadStatus
import com.gh.gamecenter.common.constant.ItemViewType
import com.gh.gamecenter.common.utils.dip2px
import com.gh.gamecenter.common.utils.safelyGetInRelease
import com.gh.gamecenter.common.utils.toBinding
import com.gh.gamecenter.common.viewholder.FooterViewHolder
import com.gh.gamecenter.core.runOnIoThread
import com.gh.gamecenter.entity.AmwayCommentEntity
import com.gh.gamecenter.entity.SubjectEntity
import com.gh.gamecenter.eventbus.EBDownloadStatus
import com.gh.gamecenter.feature.exposure.ExposureEvent
import com.gh.gamecenter.feature.exposure.ExposureSource
import com.gh.gamecenter.game.GameAndPosition
import com.gh.gamecenter.game.horizontal.GameHorizontalAdapter
import com.gh.gamecenter.game.horizontal.GameHorizontalSlideAdapter
import com.gh.gamecenter.game.rank.RankCollectionAdapter
import com.gh.gamecenter.game.vertical.GameVerticalAdapter
import com.gh.gamecenter.game.vertical.OnPagerSnapScrollListener
import com.gh.gamecenter.gamedetail.rating.RatingReplyActivity
import com.gh.gamecenter.home.amway.HomeAmwayListViewHolder
import com.gh.gamecenter.home.discovercard.DiscoverCardGameAdapter
import com.gh.gamecenter.home.discovercard.HomeDiscoverCardViewHolder
import com.gh.gamecenter.home.gamecollection.HomeGameCollectionViewHolder
import com.gh.gamecenter.home.horizontalslidevideo.HomeHorizontalSlideVideoAdapter
import com.gh.gamecenter.home.recommend.HomeRecommendItemViewHolder
import com.gh.gamecenter.home.slide.HomeSlideListAdapter
import com.gh.gamecenter.home.slide.HomeSlideListViewHolder
import com.gh.gamecenter.home.slide.HomeSlideWithCardsViewHolder
import com.gh.gamecenter.home.test_v2.HomeGameTestV2GameListRvAdapter
import com.gh.gamecenter.home.test_v2.HomeGameTestV2ViewModel
import com.gh.gamecenter.home.test_v2.HomeItemGameTestV2ViewHolder
import com.gh.gamecenter.home.video.ScrollCalculatorHelper
import com.gh.gamecenter.setting.SettingBridge
import com.gh.vspace.HomeRecentVGameAdapter
import com.gh.vspace.HomeRecentVGameViewHolder
import com.gh.vspace.VHelper
import com.halo.assistant.fragment.game.GamePluginAdapter
import com.lightgame.download.DownloadEntity

class HomeFragmentAdapter(
    context: Context,
    private val lifecycleOwner: LifecycleOwner,
    val viewModel: HomeViewModel,
    private val mHomeGameTestV2ViewModel: HomeGameTestV2ViewModel,
    private val mLayoutManager: LinearLayoutManager,
    private val mScrollCalculatorHelper: ScrollCalculatorHelper,
    private val mCallback: (colorStr: Int) -> Unit
) : DiffUtilAdapter<HomeItemData>(context), IExposable {

    private var mLoadStatus: LoadStatus? = null
    private val mLegacyHomeFragmentAdapterAssistant by lazy {
        LegacyHomeFragmentAdapterAssistant(mContext, this, mBasicExposureSource)
    }
    private val mBasicExposureSource by lazy { listOf(ExposureSource("新首页", "")) }

    override fun areItemsTheSame(oldItem: HomeItemData?, newItem: HomeItemData?): Boolean {
        // recyclerView 仅只会存在一个 item 的，只要 item 对应的值不为空即为 true
        if (oldItem?.slides != null && newItem?.slides != null) return true
        if (oldItem?.recommends != null && newItem?.recommends != null) return true
        if (oldItem?.pluginList != null && newItem?.pluginList != null) return true
        if (oldItem?.recentVGame != null && newItem?.recentVGame != null) return true

        // recyclerView 可存在多个 item 的，需要需要比较它们的 id 或特征值
        if (oldItem?.amway != null && newItem?.amway != null) {
            return oldItem.amway?.firstOrNull()?.id == newItem.amway?.firstOrNull()?.id
        }

        if (oldItem?.gameCollection != null && newItem?.gameCollection != null) {
            return oldItem.gameCollection?.firstOrNull()?.gameCollectionItem?.id == newItem.gameCollection?.firstOrNull()?.gameCollectionItem?.id
        }

        if (oldItem?.attachGame != null && newItem?.attachGame != null) {
            return oldItem.attachGame?.linkId == newItem.attachGame?.linkId
        }

        if (oldItem?.lineDivider != null && newItem?.lineDivider != null) {
            return oldItem.lineDivider == newItem.lineDivider
        }

        if (oldItem?.game != null && newItem?.game != null) {
            return oldItem.game?.id == newItem.game?.id
        }

        if (oldItem?.columnHead != null && newItem?.columnHead != null) {
            return oldItem.columnHead?.name == newItem.columnHead?.name
        }

        if (oldItem?.horizontalColumn != null && newItem?.horizontalColumn != null) {
            return oldItem.horizontalColumn?.id == newItem.horizontalColumn?.id
        }

        if (oldItem?.image != null && newItem?.image != null) {
            return oldItem.image?.id == newItem.image?.id
        }

        if (oldItem?.verticalSlide != null && newItem?.verticalSlide != null) {
            return oldItem.verticalSlide?.id == newItem.verticalSlide?.id
        }

        if (oldItem?.horizontalSlide != null && newItem?.horizontalSlide != null) {
            return oldItem.horizontalSlide?.id == newItem.horizontalSlide?.id
        }

        if (oldItem?.gallery != null && newItem?.gallery != null) {
            return oldItem.gallery?.id == newItem.gallery?.id
        }

        if (oldItem?.gallerySlide != null && newItem?.gallerySlide != null) {
            return oldItem.gallerySlide?.id == newItem.gallerySlide?.id
        }

        if (oldItem?.imageSlide != null && newItem?.imageSlide != null) {
            return oldItem.imageSlide?.id == newItem.imageSlide?.id
        }

        if (oldItem?.columnCollection != null && newItem?.columnCollection != null) {
            return oldItem.columnCollection?.id == newItem.columnCollection?.id
        }

        if (oldItem?.commonCollection != null && newItem?.commonCollection != null) {
            return oldItem.commonCollection?.id == newItem.commonCollection?.id
        }

        if (oldItem?.commonCollection12 != null && newItem?.commonCollection12 != null) {
            return oldItem.commonCollection12?.id == newItem.commonCollection12?.id && oldItem.offset == newItem.offset
        }

        if (oldItem?.rankCollection != null && newItem?.rankCollection != null) {
            return oldItem.rankCollection?.id == newItem.rankCollection?.id
        }

        if (oldItem?.doubleCardColumn != null && newItem?.doubleCardColumn != null) {
            return oldItem.doubleCardColumn?.id == newItem.doubleCardColumn?.id && oldItem.offset == newItem.offset
        }

        if (oldItem?.bigImageRecommend != null && newItem?.bigImageRecommend != null) {
            return oldItem.bigImageRecommend?.id == newItem.bigImageRecommend?.id
        }

        if (oldItem?.blankDivider != null && newItem?.blankDivider != null) {
            return oldItem.blankDivider == newItem.blankDivider
        }

        if (oldItem?.discoverCard != null && newItem?.discoverCard != null) {
            return oldItem.discoverCard == newItem.discoverCard
        }

        if (oldItem?.gameTestV2Entity != null && newItem?.gameTestV2Entity != null) {
            return oldItem.gameTestV2Entity?.pageId == newItem.gameTestV2Entity?.pageId
        }

        if (oldItem?.horizontalSlideVideo != null && newItem?.horizontalSlideVideo != null) {
            return oldItem.horizontalSlideVideo?.id == newItem.horizontalSlideVideo?.id
        }

        return false
    }

    override fun areContentsTheSame(oldItem: HomeItemData?, newItem: HomeItemData?): Boolean {
        // 右侧卡片每次刷新都不一样
        if (oldItem?.homeSubSlides != null && newItem?.homeSubSlides != null) {
            return false
        }
        return super.areContentsTheSame(oldItem, newItem)
    }

    fun setLoadStatus(status: LoadStatus) {
        // 重置偏移
        if (status == LoadStatus.INIT_LOADED) {
            mLegacyHomeFragmentAdapterAssistant.resetOffset()
        }

        this.mLoadStatus = status
        notifyItemChanged(itemCount - 1)
    }

    override fun getItemViewType(position: Int): Int {
        if (itemCount == position + 1) return FOOTER_ITEM

        val itemData = mDataList[position]
        if (itemData.slides != null && itemData.homeSubSlides != null) return SLIDE_WITH_CARDS_ITEM
        if (itemData.slides != null) return SLIDE_ITEM
        if (itemData.recommends != null) return RECOMMENDS_ITEM
        if (itemData.attachGame != null) return GAME_ITEM
        if (itemData.amway != null) return AMWAY_ITEM
        if (itemData.gameCollection != null) return GAME_COLLECTION_ITEM
        if (itemData.recentVGame != null) return RECENT_V_GAME
        if (itemData.discoverCard != null) return DISCOVER_CARD
        if (itemData.lineDivider != null) return DIVIDER_ITEM
        if (itemData.gameTestV2Entity != null) return COLUMN_TEST_V2
        if (itemData.unknownData != null) return UNKNOWN_ITEM

        return mLegacyHomeFragmentAdapterAssistant.getLegacyItemType(itemData)
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
        return when (viewType) {
            SLIDE_ITEM -> HomeSlideListViewHolder(parent.toBinding(), mCallback)
            SLIDE_WITH_CARDS_ITEM -> HomeSlideWithCardsViewHolder(parent.toBinding(), viewModel, mCallback)
            RECOMMENDS_ITEM -> HomeRecommendItemViewHolder(parent.toBinding())
            GAME_ITEM -> HomeGameItemViewHolder(parent.toBinding())
            AMWAY_ITEM -> HomeAmwayListViewHolder(parent.toBinding())
            GAME_COLLECTION_ITEM -> HomeGameCollectionViewHolder(parent.toBinding())
            DIVIDER_ITEM -> HomeDividerViewHolder(parent.toBinding())
            RECENT_V_GAME -> HomeRecentVGameViewHolder(parent.toBinding())
            DISCOVER_CARD -> HomeDiscoverCardViewHolder(parent.toBinding())
            COLUMN_TEST_V2 -> HomeItemGameTestV2ViewHolder(parent.toBinding(), mHomeGameTestV2ViewModel, lifecycleOwner)

            FOOTER_ITEM -> FooterViewHolder(mLayoutInflater.inflate(R.layout.refresh_footerview, parent, false))
            UNKNOWN_ITEM -> ReuseViewHolder(mLayoutInflater.inflate(R.layout.home_unknown_item, parent, false))

            // 原游戏板块样式
            else -> return mLegacyHomeFragmentAdapterAssistant.createLegacyViewHolder(parent, viewType)
        }
    }

    override fun getItemCount(): Int {
        return if (mDataList.isEmpty()) 0 else mDataList.size + 1 // 1: footer
    }

    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        when (holder) {
            is HomeSlideListViewHolder -> {
                // 根据首页是否有其它 tab 设置不同的 marginTop
                val marginTop = if (viewModel.homeOnlyWithoutOtherTab) 4F.dip2px() else 0
                (holder.binding.recyclerView.layoutParams as ConstraintLayout.LayoutParams)
                    .setMargins(0, marginTop, 0, 0)
                holder.bindSlideList(mDataList[position], mBasicExposureSource)
            }
            is HomeSlideWithCardsViewHolder -> {
                holder.bindSlideWithCards(mDataList[position], mBasicExposureSource)
            }
            is HomeRecommendItemViewHolder -> holder.bindRecommend(mDataList[position], mBasicExposureSource)
            is HomeAmwayListViewHolder -> bindAmway(holder, position)
            is HomeGameItemViewHolder -> bindAttachGame(holder, position)
            is FooterViewHolder -> bindFooterView(holder)
            is ReuseViewHolder -> bindUnknown(holder)
            is HomeDividerViewHolder -> holder.bindView(mDataList[position].lineDivider ?: 1F)
            is HomeGameCollectionViewHolder -> bindGameCollection(holder, position)
            is HomeRecentVGameViewHolder -> bindRecentVGame(holder, position)
            is HomeDiscoverCardViewHolder -> bindDiscoverCard(holder, position)
            is HomeItemGameTestV2ViewHolder -> bindGameTestV2ViewHolder(holder, position)

            else -> mLegacyHomeFragmentAdapterAssistant.bindLegacyViewHolder(
                holder,
                mDataList[position],
                position,
                mScrollCalculatorHelper
            )
        }
    }

    private fun bindUnknown(holder: ReuseViewHolder) {
        holder.itemView.setOnClickListener {
            mContext.startActivity(SettingBridge.getAboutIntent(mContext, true))
        }
    }

    private fun bindAmway(holder: HomeAmwayListViewHolder, position: Int) {
        val homeItemData = mDataList[position]
        val amwayList = homeItemData.amway!!

        val exposureList = arrayListOf<ExposureEvent>()
        for (amway in amwayList) {
            runOnIoThread(true) {
                val event = ExposureEvent.createEventWithSourceConcat(
                    gameEntity = amway.game.toGameEntity(),
                    basicSource = mBasicExposureSource,
                    source = listOf(ExposureSource("安利墙", ""))
                )
                exposureList.add(event)
            }
        }
        homeItemData.exposureEventList = exposureList

        val clickClosure: (View, Int, AmwayCommentEntity) -> Unit = { v, itemPosition, amway ->
            val path = "(首页安利墙)"
            when (v.id) {
                R.id.rating_block -> {
                    val intent = RatingReplyActivity.getIntent(
                        mContext,
                        amway.game.id,
                        amway.comment.id,
                        false,
                        path,
                        ""
                    )
                    mContext.startActivity(intent)
                    NewLogUtils.logHomeShareWallCardClick(amway.game.name ?: "", amway.game.id, "评论内容")
                }
                R.id.user_icon_container -> {
                    DirectUtils.directToHomeActivity(mContext, amway.comment.user.id, path, "")
                    NewLogUtils.logHomeShareWallCardClick(amway.game.name ?: "", amway.game.id, "用户信息")
                }
                else -> {
                    GameDetailActivity.startGameDetailActivity(
                        mContext,
                        amway.game.id,
                        path,
                        homeItemData.exposureEventList?.safelyGetInRelease(itemPosition)
                    )
                    NewLogUtils.logHomeShareWallCardClick(amway.game.name ?: "", amway.game.id, "游戏信息")
                }
            }
        }

        holder.bindAmwayList(amwayList, clickClosure)
    }

    private fun bindGameCollection(holder: HomeGameCollectionViewHolder, position: Int) {
        val homeItemData = mDataList[position]
        val gameCollectionItemDataList = homeItemData.gameCollection ?: listOf()

        val exposureList = arrayListOf<ExposureEvent>()
        for (gameCollectionItemData in gameCollectionItemDataList) {
            runOnIoThread(true) {
                val gameCollection = gameCollectionItemData.gameCollectionItem
                val gameCollectionSource =
                    listOf(ExposureSource("游戏单", "${gameCollection?.title} + ${gameCollection?.id}"))
                val gameExposureList = arrayListOf<ExposureEvent>()
                gameCollection?.games?.take(3)?.forEachIndexed { index, game ->
                    gameExposureList.add(
                        ExposureEvent.createEventWithSourceConcat(
                            gameEntity = game.toGameEntity().apply {
                                isAdData = gameCollection.adIconActive
                                outerSequence = homeItemData.blockPosition
                                sequence = gameCollectionItemData.gameStartPosition + index + 1
                            },
                            basicSource = mBasicExposureSource,
                            source = gameCollectionSource
                        )
                    )
                }
                gameCollectionItemData.exposureEventList = gameExposureList
                exposureList.addAll(gameExposureList)
            }
        }
        homeItemData.exposureEventList = exposureList
        holder.bindGameCollectionList(gameCollectionItemDataList, "首页内容列表")
    }

    private fun bindRecentVGame(holder: HomeRecentVGameViewHolder, position: Int) {
        val homeItemData = mDataList[position]

        val exposureEventList = arrayListOf<ExposureEvent>()
        runOnIoThread(true) {
            homeItemData.recentVGame?.forEach {
                val event = ExposureEvent.createEventWithSourceConcat(
                    gameEntity = VHelper.toGameEntity(it.downloadEntity),
                    basicSource = mBasicExposureSource,
                    source = listOf(ExposureSource("最近在玩", ""))
                )
                exposureEventList.add(event)
            }
        }
        homeItemData.exposureEventList = exposureEventList

        if (!homeItemData.recentVGame.isNullOrEmpty()) {
            holder.bindView(homeItemData.recentVGame!!)
        }
    }

    private fun bindDiscoverCard(holder: HomeDiscoverCardViewHolder, position: Int) {
        val homeItemData = mDataList[position]
        val discoverCard = homeItemData.discoverCard!!
        val binding = holder.binding
        val exposureEventList = arrayListOf<ExposureEvent>()
        val listExposureEventList = arrayListOf<ExposureEvent>()
        val spanCount = 3

        val snapHelper = holder.bindView(discoverCard, "首页", position)

        val exposureClosure: (Int) -> Unit = {
            val gameList = discoverCard.games
            runOnIoThread(true) {
                listExposureEventList.clear()

                val startOffset = it * spanCount
                val endOffset = if (startOffset + spanCount >= gameList.size) {
                    gameList.size
                } else {
                    startOffset + spanCount
                }
                for (i in startOffset until endOffset) {
                    val event = ExposureEvent.createEventWithSourceConcat(
                        gameEntity = gameList[i].apply {
                            outerSequence = homeItemData.blockPosition
                            sequence = i
                        },
                        basicSource = mBasicExposureSource,
                        source = listOf(ExposureSource("发现", gameList[i].getTypeName()))
                    )
                    gameList[i].exposureEvent = event
                    listExposureEventList.add(event)
                }
                exposureEventList.addAll(listExposureEventList)
            }
        }
        exposureClosure(0)

        binding.recyclerView.addOnScrollListener(OnPagerSnapScrollListener(snapHelper) {
            exposureClosure(it)
        })

        homeItemData.exposureEventList = exposureEventList
    }

    private fun bindAttachGame(holder: HomeGameItemViewHolder, position: Int) {
        val homeItemData = mDataList[position]
        val attachGame = homeItemData.attachGame
        val subjectEntity = SubjectEntity().apply {
            id = attachGame?.linkId
            type = attachGame?.linkType
            linkText = attachGame?.linkText ?: ""
            displayContent = attachGame?.displayContent ?: ""
            recommendText = attachGame?.recommendText ?: ""
            linkGame = attachGame?.linkGame
            adIconActive = attachGame?.adIconActive ?: false
        }
        holder.bindAttachGame(holder, subjectEntity, this, mBasicExposureSource, position, "新首页") {
            homeItemData.exposureEvent = it
        }
    }

    private fun bindGameTestV2ViewHolder(holder: HomeItemGameTestV2ViewHolder, position: Int) {
        val exposureItemData = mDataList.getOrNull(position)
        val data = exposureItemData?.gameTestV2Entity ?: return
        holder.bindData(data, exposureItemData, mBasicExposureSource, position)
    }

    private fun bindFooterView(holder: FooterViewHolder) {
        holder.initFooterViewHolder(
            mLoadStatus == LoadStatus.LIST_LOADING,
            mLoadStatus == LoadStatus.LIST_FAILED,
            mLoadStatus == LoadStatus.LIST_OVER,
            R.string.load_over_with_click_hint
        ) {
            if (mLoadStatus == LoadStatus.LIST_OVER) {
                mLayoutManager.scrollToPosition(0)
            } else if (mLoadStatus == LoadStatus.LIST_FAILED) {
                viewModel.getHomeContent(false)
                notifyItemChanged(itemCount - 1)
            }
        }
    }

    fun notifyItemByDownload(download: DownloadEntity) {
        val data = getGameEntityByPackage(download.packageName)
        for (gameAndPosition in data) {
            if (gameAndPosition.entity != null && gameAndPosition.entity.name == download.name) {
                val entryMap = gameAndPosition.entity.getEntryMap()
                entryMap[download.platform] = download
            }
            if (getItemViewType(gameAndPosition.position) == ItemViewType.VERTICAL_SLIDE_ITEM
                || getItemViewType(gameAndPosition.position) == ItemViewType.GAME_PLUGIN
                || getItemViewType(gameAndPosition.position) == SLIDE_ITEM
                || getItemViewType(gameAndPosition.position) == ItemViewType.RANK_COLLECTION
                || getItemViewType(gameAndPosition.position) == RECENT_V_GAME
                || getItemViewType(gameAndPosition.position) == ItemViewType.GAME_SUBJECT
                || getItemViewType(gameAndPosition.position) == ItemViewType.GAME_SUBJECT_SLIDE
                || getItemViewType(gameAndPosition.position) == DISCOVER_CARD
                || getItemViewType(gameAndPosition.position) == ItemViewType.HORIZONTAL_SLIDE_VIDEO
                || getItemViewType(gameAndPosition.position) == COLUMN_TEST_V2
            ) {
                val view = mLayoutManager.findViewByPosition(gameAndPosition.position)
                val recyclerView = view?.findViewById<RecyclerView>(R.id.recycler_view)
                when (val adapter = recyclerView?.adapter) {
                    is GameVerticalAdapter -> adapter.notifyItemByDownload(download)
                    is GamePluginAdapter -> adapter.notifyItemByDownload(download)
                    is HomeSlideListAdapter -> adapter.notifyItemByDownload(download)
                    is RankCollectionAdapter -> adapter.notifyItemByDownload(download)
                    is GameHorizontalAdapter -> adapter.notifyItemByDownload(download)
                    is GameHorizontalSlideAdapter -> adapter.notifyItemByDownload(download)
                    is HomeRecentVGameAdapter -> adapter.notifyItemByDownload(download)
                    is DiscoverCardGameAdapter -> adapter.notifyItemByDownload(download)
                    is HomeGameTestV2GameListRvAdapter -> adapter.notifyItemByDownload(download)
                    is HomeHorizontalSlideVideoAdapter -> adapter.notifyItemByDownload(download)
                }
            } else {
                notifyItemChanged(gameAndPosition.position)
            }
        }
    }

    fun notifyItemAndRemoveDownload(status: EBDownloadStatus) {
        val data = getGameEntityByPackage(status.packageName)
        for (gameAndPosition in data) {
            if (gameAndPosition.entity != null && gameAndPosition.entity.name == status.name) {
                gameAndPosition.entity.getEntryMap().remove(status.platform)
            }
            notifyChildItem(gameAndPosition.position, status.packageName)
        }
    }

    fun notifyChildItem(position: Int, packageName: String) {
        if (getItemViewType(position) == ItemViewType.VERTICAL_SLIDE_ITEM
            || getItemViewType(position) == ItemViewType.GAME_PLUGIN
            || getItemViewType(position) == SLIDE_ITEM
            || getItemViewType(position) == ItemViewType.RANK_COLLECTION
            || getItemViewType(position) == ItemViewType.GAME_SUBJECT
            || getItemViewType(position) == ItemViewType.GAME_SUBJECT_SLIDE
            || getItemViewType(position) == DISCOVER_CARD
            || getItemViewType(position) == COLUMN_TEST_V2
            || getItemViewType(position) == ItemViewType.HORIZONTAL_SLIDE_VIDEO
        ) {
            val view = mLayoutManager.findViewByPosition(position)
            val recyclerView = view?.findViewById<RecyclerView>(R.id.recycler_view)
            when (val adapter = recyclerView?.adapter) {
                is RankCollectionAdapter -> adapter.notifyChildItem()
                is GameVerticalAdapter -> adapter.notifyChildItem(packageName)
                is GameHorizontalAdapter -> adapter.notifyChildItem(packageName)
                is GameHorizontalSlideAdapter -> adapter.notifyChildItem(packageName)
                is DiscoverCardGameAdapter -> adapter.notifyChildItem(packageName)
                is HomeGameTestV2GameListRvAdapter -> adapter.notifyChildItem(packageName)
                is HomeHorizontalSlideVideoAdapter -> adapter.notifyChildItem(packageName)
                else -> recyclerView?.adapter?.notifyDataSetChanged()
            }
        } else {
            notifyItemChanged(position)
        }
    }

    fun getGameEntityByPackage(packageName: String): List<GameAndPosition> {
        val positionList = ArrayList<GameAndPosition>()
        val positionMap = viewModel.positionAndPackageMap.value ?: return positionList
        for (key in positionMap.keys) {
            if (key.contains(packageName)) {
                val position = positionMap[key]!!
                if (position >= mDataList.size) return arrayListOf()
                val itemData = mDataList[position]
                val slides = itemData.slides

                if (slides != null) {
                    main@
                    for (slide in slides) {
                        val linkGame = slide.linkGame
                        if (linkGame != null) {
                            for (apkEntity in linkGame.getApk()) {
                                if (apkEntity.packageName == packageName) {
                                    positionList.add(GameAndPosition(linkGame, position))
                                    break@main
                                }
                            }
                        }
                    }
                    continue
                }

                val attachGame = itemData.attachGame?.linkGame
                val recentVGame = itemData.recentVGame

                if (attachGame != null || recentVGame != null) {
                    positionList.add(GameAndPosition(attachGame, position))
                    continue
                }

                val discoverCard = itemData.discoverCard
                if (discoverCard != null) {
                    discoverCard.games.forEach {
                        for (apkEntity in it.getApk()) {
                            if (apkEntity.packageName == packageName) {
                                positionList.add(GameAndPosition(it, position))
                            }
                        }
                    }
                    continue
                }
                //新游开测相关条目
                val gameTestV2 = itemData.gameTestV2Entity
                val gameTestV2List = mHomeGameTestV2ViewModel.getDataListLiveData().value
                gameTestV2List?.forEach { gameDataWrapper ->
                    val gameEntity = gameDataWrapper.gameData
                    if (gameEntity != null) {
                        for (apkEntity in gameEntity.getApk()) {
                            if (apkEntity.packageName == packageName) {
                                positionList.add(GameAndPosition(gameEntity, position))
                            }
                        }
                    }
                }
                if (gameTestV2 != null) continue

                // 原游戏板块样式
                mLegacyHomeFragmentAdapterAssistant.getLegacyGameEntityByPackage(
                    positionList,
                    itemData,
                    packageName,
                    position
                )
            }
        }
        return positionList
    }

    override fun getEventByPosition(pos: Int): ExposureEvent? {
        return mDataList[pos].exposureEvent
    }

    override fun getEventListByPosition(pos: Int): List<ExposureEvent>? {
        return mDataList[pos].exposureEventList
    }

    companion object {
        const val SLIDE_ITEM: Int = 100
        const val SLIDE_WITH_CARDS_ITEM: Int = 120
        const val RECOMMENDS_ITEM: Int = 101
        const val GAME_ITEM: Int = 102
        const val AMWAY_ITEM: Int = 103
        const val DIVIDER_ITEM: Int = 114
        const val FOOTER_ITEM: Int = 110
        const val UNKNOWN_ITEM: Int = 111
        const val GAME_COLLECTION_ITEM: Int = 116
        const val RECENT_V_GAME: Int = 117
        const val DISCOVER_CARD: Int = 118
        const val COLUMN_TEST_V2: Int = 119 //新游开测
    }
}