smartRefreshLayout.setEnableScrollContentWhenLoaded(false)

import com.google.gson.Gson
import com.google.gson.JsonSyntaxException
import com.google.gson.TypeAdapter
import com.google.gson.reflect.TypeToken
import com.google.gson.stream.JsonReader
import com.google.gson.stream.JsonToken
import okhttp3.ResponseBody
import retrofit2.Converter
import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type

class ResponseBodyConverter(val gson: Gson, val type: Type) :
    Converter<ResponseBody, BaseResponse<Any>> {
    override fun convert(value: ResponseBody): BaseResponse<Any> {
        val dataType = GenericsUtils.getParameterUpperBound(
            0,
            type as ParameterizedType
        )
        val baseResponse = BaseResponse<Any>()
        val jsonReader = JsonReader(value.charStream())
        try {
            jsonReader.beginObject()
            while (jsonReader.hasNext()) {
                val name: String = jsonReader.nextName()
                when (name) {
                    "code" -> {
                        baseResponse.code = jsonReader.nextString()
                    }
                    "msg" -> {
                        // this works, but do not do this.
                        if (jsonReader.peek() == JsonToken.NULL) {
                            jsonReader.nextNull()
                            baseResponse.msg = null
                        } else {
                            baseResponse.msg = jsonReader.nextString()
                        }
                    }
                    "data" -> {
                        val mapped: TypeAdapter<*>? = gson.getAdapter(TypeToken.get(dataType))
                        baseResponse.data = mapped?.read(jsonReader)
                    }
                    else -> {
                        jsonReader.skipValue()
                    }
                }
            }
        } catch (e: IllegalStateException) {
            throw JsonSyntaxException(e)
        } catch (e: IllegalAccessException) {
            throw AssertionError(e)
        }
        jsonReader.endObject()
        return baseResponse
    }
}

private var totalHeight: Int = 0
private var visibleHeight: Int = 0
private var screenHeight = 0

fun getViewRate(): String? =
if (totalHeight <= 0 || visibleHeight < 0) null
else "${(visibleHeight * 100 / totalHeight)}%"

private fun bindViewTreeObserver() {
    cleanCache()
    contentTv.post {
        totalHeight = contentTv.height
        screenHeight = ScreenUtils.getScreenHeight(context)
        contentVisibleRate()
    }
    contentTv.viewTreeObserver.addOnScrollChangedListener(mScrollChangeListener)
}

private fun cleanCache() {
    totalHeight = 0
    screenHeight = 0
    visibleHeight = 0
}

private val mScrollChangeListener = ViewTreeObserver.OnScrollChangedListener {
    contentVisibleRate()
}

private fun contentVisibleRate() {
    val location = IntArray(2)
    contentTv.getLocationOnScreen(location)
    visibleHeight = (screenHeight - location[1]).coerceAtLeast(visibleHeight)
    if (visibleHeight >= totalHeight) {
        visibleHeight = totalHeight
        removeOnScrollChangedListener()
    }
}

private fun removeOnScrollChangedListener() {
    mScrollChangeListener?.let {
        contentTv.viewTreeObserver.removeOnScrollChangedListener(mScrollChangeListener)
    }
}

import androidx.recyclerview.widget.GridLayoutManager
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.recyclerview.widget.StaggeredGridLayoutManager

object RecyclerViewHelper {
  /**
   * RecyclerView 注册加载更多监听
   */
  @JvmStatic
  fun addOnScrollListener(recyclerView: RecyclerView, loadMore: () -> Unit) {
    recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
      override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
        super.onScrollStateChanged(recyclerView, newState)
        if (newState == RecyclerView.SCROLL_STATE_IDLE) {
          val layoutManager = recyclerView.layoutManager
          if (layoutManager is LinearLayoutManager) {
            val lastPosition = layoutManager.findLastCompletelyVisibleItemPosition()
            val count = layoutManager.itemCount
            if (lastPosition >= count - 2) {
              loadMore()
              return@onScrollStateChanged
            }
          } else if (layoutManager is StaggeredGridLayoutManager) {
            val spanCount = layoutManager.spanCount
            val count = layoutManager.itemCount
            val result = IntArray(spanCount)
            layoutManager.findLastCompletelyVisibleItemPositions(result)
            for (it in result) {
              if (it >= count - spanCount - 1) {
                loadMore()
                return@onScrollStateChanged
              }
            }
          } else if (layoutManager is GridLayoutManager) {
            val spanCount = layoutManager.spanCount
            val count = layoutManager.itemCount
            val lastPosition = layoutManager.findLastCompletelyVisibleItemPosition()
            if (lastPosition >= count - spanCount - 1) {
              loadMore()
              return@onScrollStateChanged
            }

          }
        }
      }
    })
  }


  /**
     * 判断是否一屏显示
     *
     * 错误或者空了返回 false
     */
  @JvmStatic
  fun isOneScreen(recyclerView: RecyclerView?): Boolean {
    recyclerView?.let {
      val layoutManager = recyclerView.layoutManager
      if (layoutManager is LinearLayoutManager) {
        // include GridLayoutManager
        val count = layoutManager.itemCount
        return count > 0 &&
        layoutManager.findFirstCompletelyVisibleItemPosition() == 0 &&
        layoutManager.findLastCompletelyVisibleItemPosition() == count - 1
      } else if (layoutManager is StaggeredGridLayoutManager) {
        val spanCount = layoutManager.spanCount
        val count = layoutManager.itemCount
        val last = IntArray(spanCount)
        val first = IntArray(spanCount)
        layoutManager.findLastCompletelyVisibleItemPositions(last)
        layoutManager.findFirstCompletelyVisibleItemPositions(first)
        return count > 0 && first.min() == 0 && last.max() == count - 1
      }
    }

    return false
  }

  private fun IntArray.min(): Int {
    if (this.isNotEmpty()) {
      var result = this[0]
      this.forEach {
        if (result > it) result = it
      }
      return result
    }
    return -1
  }

  private fun IntArray.max(): Int {
    if (this.isNotEmpty()) {
      var result = this[0]
      this.forEach {
        if (result < it) result = it
      }
      return result
    }
    return -1
  }
}

override fun createViewPagerAdapter(): RecyclerView.Adapter<*> {
    val items = items // avoids resolving the ViewModel multiple times
    return object : FragmentStateAdapter(this) {
        override fun createFragment(position: Int): PageFragment {
            val itemId = items.itemId(position)
            val itemText = items.getItemById(itemId)
            return PageFragment.create(itemText)
        }
        override fun getItemCount(): Int = items.size
        override fun getItemId(position: Int): Long = items.itemId(position)
        override fun containsItem(itemId: Long): Boolean = items.contains(itemId)
    }
}

/** A very simple collection of items. Optimized for simplicity (i.e. not performance). */
class ItemsViewModel : ViewModel() {
    private var nextValue = 1L

    private val items = (1..9).map { longToItem(nextValue++) }.toMutableList()

    fun getItemById(id: Long): String = items.first { itemToLong(it) == id }
    fun itemId(position: Int): Long = itemToLong(items[position])
    fun contains(itemId: Long): Boolean = items.any { itemToLong(it) == itemId }
    fun addNewAt(position: Int) = items.add(position, longToItem(nextValue++))
    fun removeAt(position: Int) = items.removeAt(position)
    fun createIdSnapshot(): List<Long> = (0 until size).map { position -> itemId(position) }
    val size: Int get() = items.size

    private fun longToItem(value: Long): String = "item#$value"
    private fun itemToLong(value: String): Long = value.split("#")[1].toLong()
}

import android.content.Context
import android.util.AttributeSet
import android.view.MotionEvent
import android.view.View
import android.view.ViewConfiguration
import android.widget.FrameLayout
import androidx.viewpager2.widget.ViewPager2
import androidx.viewpager2.widget.ViewPager2.ORIENTATION_HORIZONTAL
import kotlin.math.absoluteValue
import kotlin.math.sign

/**
 * Layout to wrap a scrollable component inside a ViewPager2. Provided as a solution to the problem
 * where pages of ViewPager2 have nested scrollable elements that scroll in the same direction as
 * ViewPager2. The scrollable element needs to be the immediate and only child of this host layout.
 *
 * This solution has limitations when using multiple levels of nested scrollable elements
 * (e.g. a horizontal RecyclerView in a vertical RecyclerView in a horizontal ViewPager2).
 */
class NestedScrollableHost : FrameLayout {
    constructor(context: Context) : super(context)
    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)

    private var touchSlop = 0
    private var initialX = 0f
    private var initialY = 0f
    private val parentViewPager: ViewPager2?
    get() {
        var v: View? = parent as? View
        while (v != null && v !is ViewPager2) {
            v = v.parent as? View
        }
        return v as? ViewPager2
    }

    private val child: View? get() = if (childCount > 0) getChildAt(0) else null

    init {
        touchSlop = ViewConfiguration.get(context).scaledTouchSlop
    }

    private fun canChildScroll(orientation: Int, delta: Float): Boolean {
        val direction = -delta.sign.toInt()
        return when (orientation) {
            0 -> child?.canScrollHorizontally(direction) ?: false
            1 -> child?.canScrollVertically(direction) ?: false
            else -> throw IllegalArgumentException()
        }
    }

    override fun onInterceptTouchEvent(e: MotionEvent): Boolean {
        handleInterceptTouchEvent(e)
        return super.onInterceptTouchEvent(e)
    }

    private fun handleInterceptTouchEvent(e: MotionEvent) {
        val orientation = parentViewPager?.orientation ?: return

        // Early return if child can't scroll in same direction as parent
        if (!canChildScroll(orientation, -1f) && !canChildScroll(orientation, 1f)) {
            return
        }

        if (e.action == MotionEvent.ACTION_DOWN) {
            initialX = e.x
            initialY = e.y
            parent.requestDisallowInterceptTouchEvent(true)
        } else if (e.action == MotionEvent.ACTION_MOVE) {
            val dx = e.x - initialX
            val dy = e.y - initialY
            val isVpHorizontal = orientation == ORIENTATION_HORIZONTAL

            // assuming ViewPager2 touch-slop is 2x touch-slop of child
            val scaledDx = dx.absoluteValue * if (isVpHorizontal) .5f else 1f
            val scaledDy = dy.absoluteValue * if (isVpHorizontal) 1f else .5f

            if (scaledDx > touchSlop || scaledDy > touchSlop) {
                if (isVpHorizontal == (scaledDy > scaledDx)) {
                    // Gesture is perpendicular, allow all parents to intercept
                    parent.requestDisallowInterceptTouchEvent(false)
                } else {
                    // Gesture is parallel, query child if movement in that direction is possible
                    if (canChildScroll(orientation, if (isVpHorizontal) dx else dy)) {
                        // Child can scroll, disallow all parents to intercept
                        parent.requestDisallowInterceptTouchEvent(true)
                    } else {
                        // Child cannot scroll, allow all parents to intercept
                        parent.requestDisallowInterceptTouchEvent(false)
                    }
                }
            }
        }
    }
}

import android.os.Bundle
import android.view.LayoutInflater
import android.view.ViewGroup
import android.widget.Toast
import androidx.fragment.app.FragmentActivity
import androidx.recyclerview.widget.RecyclerView
import androidx.viewpager2.widget.ViewPager2

class PreviewPagesActivity : FragmentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_viewpager2)
        findViewById<ViewPager2>(R.id.view_pager).apply {
            // Set offscreen page limit to at least 1, so adjacent pages are always laid out
            offscreenPageLimit = 1
            val recyclerView = getChildAt(0) as RecyclerView
            recyclerView.apply {
                clipToPadding = false
                val leftPadding = resources.getDimensionPixelOffset(R.dimen.halfPageMargin) +
                resources.getDimensionPixelOffset(R.dimen.peekOffset)
                // setting padding on inner RecyclerView puts overscroll effect in the right place
                // TODO: expose in later versions not to rely on
                //  getChildAt(0) which might break
                setPadding(leftPadding, 0, leftPadding, 0)
            }
            adapter = Adapter()
        }
    }

    class ViewHolder(parent: ViewGroup) : RecyclerView.ViewHolder(
        LayoutInflater.from(parent.context).inflate(R.layout.item_preview_pages, parent, false)
    )

    class Adapter : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
        override fun getItemCount(): Int {
            return 10
        }

        override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
            return ViewHolder(parent)
        }

        override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
            holder.itemView.tag = position
            holder.itemView.setOnClickListener {
                Toast.makeText(it.context, "position=$position", Toast.LENGTH_LONG).show()
            }
        }
    }
}