import QtQuick
import QtQuick.Controls

ListView {
  id: listView

  property real mouseWheelSpeed: 60

  // Simple position preservation
  property real savedY: 0
  property bool justChanged: false
  property bool isUserScrolling: false

  // Kinetic scrolling momentum properties
  property real momentumVelocity: 0
  property bool isMomentumActive: false
  property real friction: 0.95
  property real minMomentumVelocity: 50
  property real maxMomentumVelocity: 2500

  flickDeceleration: 1500
  maximumFlickVelocity: 2000
  boundsBehavior: Flickable.StopAtBounds
  boundsMovement: Flickable.FollowBoundsBehavior
  pressDelay: 0
  flickableDirection: Flickable.VerticalFlick

  onMovementStarted: isUserScrolling = true
  onMovementEnded: isUserScrolling = false

  onContentYChanged: {
    if (!justChanged && isUserScrolling) {
      savedY = contentY
    }
    justChanged = false
  }

  // Restore position when model changes
  onModelChanged: {
    justChanged = true
    contentY = savedY
  }

  WheelHandler {
    id: wheelHandler

    // Tunable parameters for responsive scrolling
    property real touchpadSpeed: 1.8 // Touchpad sensitivity
    property real momentumRetention: 0.92
    property real lastWheelTime: 0
    property real momentum: 0
    property var velocitySamples: []

    function startMomentum() {
      isMomentumActive = true
      momentumTimer.start()
    }

    acceptedDevices: PointerDevice.Mouse | PointerDevice.TouchPad

    onWheel: event => {
               isUserScrolling = true // Mark as user interaction

               let currentTime = Date.now()
               let timeDelta = currentTime - lastWheelTime
               lastWheelTime = currentTime

               // Detect mouse wheel vs touchpad, seems like assuming based on the increments is the only way in QT
               const deltaY = event.angleDelta.y
               const isMouseWheel = Math.abs(deltaY) >= 120
               && (Math.abs(deltaY) % 120) === 0

               if (isMouseWheel) {
                 momentumTimer.stop()
                 isMomentumActive = false
                 velocitySamples = []
                 momentum = 0

                 const lines = Math.floor(Math.abs(deltaY) / 120)
                 const scrollAmount = (deltaY > 0 ? -lines : lines) * mouseWheelSpeed
                 let newY = listView.contentY + scrollAmount
                 newY = Math.max(
                   0, Math.min(listView.contentHeight - listView.height, newY))

                 if (listView.flicking)
                 listView.cancelFlick()

                 listView.contentY = newY
                 savedY = newY
               } else {
                 momentumTimer.stop()
                 isMomentumActive = false

                 // Calculate scroll delta based on input type
                 let delta = 0
                 if (event.pixelDelta.y !== 0) {
                   // Touchpad with pixel precision
                   delta = event.pixelDelta.y * touchpadSpeed
                 } else {
                   // Fallback for touchpad without pixel delta
                   delta = event.angleDelta.y / 8 * touchpadSpeed
                 }

                 // Track velocity for momentum
                 velocitySamples.push({
                                        "delta": delta,
                                        "time": currentTime
                                      })
                 velocitySamples = velocitySamples.filter(s => {
                                                            return currentTime - s.time < 100
                                                          })

                 // Calculate momentum velocity from samples
                 if (velocitySamples.length > 1) {
                   let totalDelta = velocitySamples.reduce((sum, s) => {
                                                             return sum + s.delta
                                                           }, 0)
                   let timeSpan = currentTime - velocitySamples[0].time
                   if (timeSpan > 0)
                   momentumVelocity = Math.max(-maxMomentumVelocity, Math.min(
                                                 maxMomentumVelocity,
                                                 totalDelta / timeSpan * 1000))
                 }

                 // Apply momentum for touchpad (smooth continuous scrolling)
                 if (event.pixelDelta.y !== 0 && timeDelta < 50) {
                   momentum = momentum * momentumRetention + delta * 0.15
                   delta += momentum
                 } else {
                   momentum = 0
                 }

                 // Apply scrolling with proper bounds checking
                 let newY = listView.contentY - delta
                 newY = Math.max(
                   0, Math.min(listView.contentHeight - listView.height, newY))

                 // Cancel any conflicting flicks and apply new position
                 if (listView.flicking)
                 listView.cancelFlick()

                 listView.contentY = newY
                 savedY = newY // Update saved position
               }

               event.accepted = true
             }

    onActiveChanged: {
      if (!active) {
        isUserScrolling = false

        // Start momentum if applicable (touchpad only)
        if (Math.abs(momentumVelocity) >= minMomentumVelocity) {
          startMomentum()
        } else {
          velocitySamples = []
          momentumVelocity = 0
        }
      }
    }
  }

  // Physics-based momentum timer for kinetic scrolling (touchpad only)
  Timer {
    id: momentumTimer
    interval: 16 // ~60 FPS
    repeat: true

    onTriggered: {
      // Apply velocity to position
      let newY = contentY - momentumVelocity * 0.016
      let maxY = Math.max(0, contentHeight - height)

      // Stop momentum at boundaries instead of bouncing
      if (newY < 0) {
        contentY = 0
        savedY = 0
        stop()
        isMomentumActive = false
        momentumVelocity = 0
        return
      } else if (newY > maxY) {
        contentY = maxY
        savedY = maxY
        stop()
        isMomentumActive = false
        momentumVelocity = 0
        return
      }

      contentY = newY
      savedY = newY // Keep updating saved position during momentum

      // Apply friction
      momentumVelocity *= friction

      // Stop if velocity too low
      if (Math.abs(momentumVelocity) < 5) {
        stop()
        isMomentumActive = false
        momentumVelocity = 0
      }
    }
  }

  // Smooth return to bounds animation
  NumberAnimation {
    id: returnToBoundsAnimation
    target: listView
    property: "contentY"
    duration: 300
    easing.type: Easing.OutQuad
  }
}