import android.content.Context
import androidx.recyclerview.widget.LinearSmoothScroller

class TopLinearSmoothScroller(context: Context?) : LinearSmoothScroller(context) {
    public override fun getVerticalSnapPreference(): Int {
        return SNAP_TO_START
    }

    override fun getHorizontalSnapPreference(): Int {
        return SNAP_TO_START
    }
}

import android.content.Context
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView

class TopScrollLinearLayoutManager(context: Context?, orientation: Int, reverseLayout: Boolean) :
    LinearLayoutManager(context, orientation, reverseLayout) {

    override fun smoothScrollToPosition(
        recyclerView: RecyclerView?,
        state: RecyclerView.State?,
        position: Int
    ) {
        val linearSmoothScroller = TopLinearSmoothScroller(recyclerView?.context)
        linearSmoothScroller.targetPosition = position
        startSmoothScroll(linearSmoothScroller)
    }
}

recyclerView.layoutManager = TopScrollLinearLayoutManager(
    this,
    LinearLayoutManager.HORIZONTAL,
    false
)
// ...
recyclerView.smoothScrollToPosition(1)

binding.recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
    override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
        super.onScrolled(recyclerView, dx, dy)
        onRecyclerScrolled(recyclerView, dx, dy)
    }

    override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
        super.onScrollStateChanged(recyclerView, newState)
    }
})

private val dp180 = dp2px(180)
private var distanceY = 0
private var current = 0
private fun onRecyclerScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
    distanceY += dy
    when {
        distanceY >= dp180 -> {
            if (current == 1) return
            recyclerView.setBackgroundColor(Color.argb(255, 246, 248, 250))
            current = 1
        }
        distanceY <= 0 -> {
            if (current == 0) return
            recyclerView.setBackgroundColor(Color.argb(0, 246, 248, 250))
            current = 0
        }
        else -> {
            recyclerView.setBackgroundColor(
                Color.argb(
                    distanceY * 255 / dp180,
                    246, 248, 250
                )
            )
            current = -1
        }
    }
}

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
  }
}

recyclerView.layoutManager = object : LinearLayoutManager(context, RecyclerView.VERTICAL, false) {
    override fun setMeasuredDimension(childrenBounds: Rect?, wSpec: Int, hSpec: Int) {
        val height = View.MeasureSpec.getSize(hSpec)
        val maxHeight = getScreenHeight() * 4 / 5
        val realHeight = height.coerceAtMost(maxHeight)
        val realHeightSpec = View.MeasureSpec.makeMeasureSpec(realHeight, AT_MOST)
        super.setMeasuredDimension(childrenBounds, wSpec, realHeightSpec)
    }
}

import android.content.Context
import android.util.AttributeSet
import android.view.MotionEvent
import android.widget.ScrollView

class ItemScrollView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : ScrollView(context, attrs, defStyleAttr) {

    override fun onInterceptTouchEvent(ev: MotionEvent?): Boolean {
        parent.requestDisallowInterceptTouchEvent(true)
        return super.onInterceptTouchEvent(ev)
    }

    private var lastY: Float = 0f

    override fun onTouchEvent(ev: MotionEvent?): Boolean {
        when (ev?.action) {
            MotionEvent.ACTION_DOWN -> {
                lastY = ev.y
            }

            MotionEvent.ACTION_MOVE -> {
                val currentY = ev.y
                this.scrollBy(0, (lastY - currentY).toInt())
                lastY = currentY
            }

            MotionEvent.ACTION_UP -> {
                lastY = 0f
            }
        }

        return canScroll()
    }

    private fun canScroll(): Boolean {
        val child = getChildAt(0)
        child?.let {
            return height < child.height
        }
        return false
    }
}

import android.content.res.Resources
import android.graphics.Rect
import android.util.TypedValue
import android.view.View
import androidx.recyclerview.widget.RecyclerView

class SimplePaddingDecoration(
    spaceDp: Int,
    val orientation: Int = RecyclerView.VERTICAL
) : RecyclerView.ItemDecoration() {
    private val dividerHeight: Int = TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_DIP,
        spaceDp.toFloat(),
        Resources.getSystem().displayMetrics
    ).toInt()

    override fun getItemOffsets(
        outRect: Rect,
        view: View,
        parent: RecyclerView,
        state: RecyclerView.State
    ) {
        val position = (view.layoutParams as RecyclerView.LayoutParams).viewLayoutPosition

        if (orientation == RecyclerView.VERTICAL) {
            // 竖直
            if (position + 1 != parent.adapter?.itemCount) {
                outRect.set(0, 0, 0, dividerHeight)
            } else {
                outRect.set(0, 0, 0, 0)
            }
        } else {
            // 水平
            if (position + 1 != parent.adapter?.itemCount) {
                outRect.set(0, 0, dividerHeight, 0)
            } else {
                outRect.set(0, 0, 0, 0)
            }
        }
    }
}

val layoutManager = StaggeredGridLayoutManager(2, RecyclerView.VERTICAL)
layoutManager.gapStrategy = StaggeredGridLayoutManager.GAP_HANDLING_NONE// 禁止左右交换
recyclerView.layoutManager = layoutManager
// decoration
recyclerView.addItemDecoration(StaggeredDividerItemDecoration(16, true))
// adapter
mAdapter = PjListVPAdapter()
recyclerView.adapter = mAdapter
// animator
recyclerView.itemAnimator = DefaultItemAnimator()

/**
 * 瀑布流ItemDecoration
 * 必须配合RecyclerView的StaggeredGridLayoutManager一起使用
 *
 * @author Dench
 * @data 2020-09-04
 */
class StaggeredDividerItemDecoration(
  space: Int, // 间隔 pix
  private val includeEdge: Boolean = false // 是否显示边距
) : ItemDecoration() {
  private val space = TypedValue.applyDimension(
    TypedValue.COMPLEX_UNIT_DIP,
    space.toFloat(),
    Resources.getSystem().displayMetrics
  ).toInt()
  
  override fun getItemOffsets(
    outRect: Rect,
    view: View,
    parent: RecyclerView,
    state: RecyclerView.State
  ) {
    val lp = view.layoutParams as StaggeredGridLayoutManager.LayoutParams
    val lm = parent.layoutManager as StaggeredGridLayoutManager
    val spanIndex: Int = lp.spanIndex
    val spanCount: Int = lm.spanCount
    if (includeEdge) {
      outRect.left = space * (spanCount - spanIndex) / spanCount
      outRect.right = space * (spanIndex + 1) / spanCount
      outRect.top = space
    } else {
      outRect.left = space * spanIndex / spanCount
      outRect.right = space * (spanCount - spanIndex - 1) / spanCount
      outRect.bottom = space
    }
  }
}