import CoreGraphics
import XCTest
@testable import LChatCore

// 🤖 The Mac feed's scroll-position arithmetic (FeedGeometry): the reading the
// per-thread scroll memory stores and the prepend re-anchor restores. Pinned
// here because both callers must agree — a drifting reading is a jumping feed.
final class FeedGeometryTests: XCTestCase {

    // A stack of equal rows laid out from `top`, keyed 1…n.
    private func rows(count: Int, height: CGFloat, top: CGFloat) -> [Int64: CGRect] {
        var out: [Int64: CGRect] = [:]
        for i in 0..<count {
            out[Int64(i + 1)] = CGRect(x: 0, y: top + CGFloat(i) * height,
                                       width: 400, height: height)
        }
        return out
    }

    func testPicksTheRowNearestTheViewportCentre() {
        // 7 × 100pt rows from y=50, viewport 800 → centre 400. Row 4 spans
        // 350…450, its midY exactly on the centre line: an unambiguous pick
        // (a tie would only pin dictionary order, which is nothing to pin).
        let r = rows(count: 7, height: 100, top: 50)
        XCTAssertEqual(FeedGeometry.centreRow(rows: r, viewportHeight: 800)?.rowID, 4)
    }

    func testFractionRoundTripsThroughTheViewport() {
        // One row at the very top of a viewport it doesn't fill → fraction 0.
        let top: [Int64: CGRect] = [1: CGRect(x: 0, y: 0, width: 400, height: 100)]
        XCTAssertEqual(FeedGeometry.centreRow(rows: top, viewportHeight: 500)?.fraction, 0)

        // The same row resting on the bottom edge → fraction 1.
        let bottom: [Int64: CGRect] = [1: CGRect(x: 0, y: 400, width: 400, height: 100)]
        XCTAssertEqual(FeedGeometry.centreRow(rows: bottom, viewportHeight: 500)?.fraction, 1)

        // Half way down → 0.5 of the travel (viewport 500 − row 100 = 400).
        let mid: [Int64: CGRect] = [1: CGRect(x: 0, y: 200, width: 400, height: 100)]
        XCTAssertEqual(FeedGeometry.centreRow(rows: mid, viewportHeight: 500)?.fraction ?? 0,
                       0.5, accuracy: 0.0001)
    }

    func testIgnoresRowsOnlyPartlyOnScreen() {
        // Row 1 straddles the top edge and row 3 the bottom; only the
        // fully-visible row 2 is a valid anchor.
        let r: [Int64: CGRect] = [
            1: CGRect(x: 0, y: -60, width: 400, height: 100),
            2: CGRect(x: 0, y: 40, width: 400, height: 100),
            3: CGRect(x: 0, y: 460, width: 400, height: 100),
        ]
        // Viewport 500: row 2 (40…140) is fully visible, row 3 (460…560) is not.
        XCTAssertEqual(FeedGeometry.centreRow(rows: r, viewportHeight: 500)?.rowID, 2)
    }

    func testGiantRowFillingTheScreenAnchorsItsTop() {
        // A code block taller than the viewport: no row is fully visible, so
        // the reading is that row's top rather than nothing at all.
        let r: [Int64: CGRect] = [9: CGRect(x: 0, y: -200, width: 400, height: 1200)]
        let a = FeedGeometry.centreRow(rows: r, viewportHeight: 500)
        XCTAssertEqual(a?.rowID, 9)
        XCTAssertEqual(a?.fraction, 0)
    }

    func testNoReadingWithoutGeometry() {
        XCTAssertNil(FeedGeometry.centreRow(rows: [:], viewportHeight: 500))
        XCTAssertNil(FeedGeometry.centreRow(rows: rows(count: 3, height: 100, top: 0),
                                            viewportHeight: 0))
        // Every row above the viewport (the stranded-offset wedge) reads as
        // nothing — the caller falls back to its own rescue.
        let above: [Int64: CGRect] = [1: CGRect(x: 0, y: -900, width: 400, height: 100)]
        XCTAssertNil(FeedGeometry.centreRow(rows: above, viewportHeight: 500))
    }

    // ---- lastRowIsFlush: the pin verify's states ------------------------

    // A tall chat pinned: the newest row rests at the viewport's bottom. The
    // viewport is already the composer-reduced height (safeAreaInset shrinks
    // the scroll view's frame), so nothing is subtracted for the band.
    func testPinnedTallChatIsFlush() {
        let last = CGRect(x: 0, y: 300, width: 400, height: 79) // maxY 379 of 380
        XCTAssertTrue(FeedGeometry.lastRowIsFlush(last: last, first: nil, viewportHeight: 380))
    }

    // The typing bubble sits between the newest row and the bottom — still
    // flush, or the verify would never settle in a live conversation.
    func testTypingBubbleGapIsStillFlush() {
        let last = CGRect(x: 0, y: 240, width: 400, height: 90) // maxY 330 of 380
        XCTAssertTrue(FeedGeometry.lastRowIsFlush(last: last, first: nil, viewportHeight: 380))
    }

    // Bug #900: the offset outlived the content and every row sits ABOVE the
    // viewport with a negative maxY. Never flush — revealing it shows blank.
    func testStrandedAboveIsNotFlush() {
        let last = CGRect(x: 0, y: -800, width: 400, height: 100) // maxY -700
        XCTAssertFalse(FeedGeometry.lastRowIsFlush(last: last, first: nil, viewportHeight: 380))
    }

    // Scrolled back: the newest row is below the fold.
    func testScrolledBackIsNotFlush() {
        let last = CGRect(x: 0, y: 900, width: 400, height: 100)
        XCTAssertFalse(FeedGeometry.lastRowIsFlush(last: last, first: nil, viewportHeight: 380))
    }

    // A chat too short to fill the pane reads from the TOP: flush means the
    // first row starts at the top edge and the last one is inside the viewport.
    func testShortChatIsFlushWhenTopAligned() {
        let first = CGRect(x: 0, y: 0, width: 400, height: 60)
        let last = CGRect(x: 0, y: 70, width: 400, height: 60) // maxY 130
        XCTAssertTrue(FeedGeometry.lastRowIsFlush(last: last, first: first, viewportHeight: 380))
        // Dragged ABOVE the top edge — the offset outran the content, which is
        // the short-chat form of the #900 wedge.
        let stranded = CGRect(x: 0, y: -30, width: 400, height: 60)
        XCTAssertFalse(FeedGeometry.lastRowIsFlush(
            last: CGRect(x: 0, y: 40, width: 400, height: 60), first: stranded,
            viewportHeight: 380))
    }

    func testNoGeometryIsNeverFlush() {
        XCTAssertFalse(FeedGeometry.lastRowIsFlush(last: nil, first: nil, viewportHeight: 380))
        XCTAssertFalse(FeedGeometry.lastRowIsFlush(
            last: CGRect(x: 0, y: 0, width: 400, height: 60), first: nil, viewportHeight: 0))
    }

    func testNearBottomSlack() {
        // The newest row resting just under the viewport bottom (behind the
        // composer inset) still counts as at-the-bottom.
        XCTAssertTrue(FeedGeometry.isNearBottom(
            lastRow: CGRect(x: 0, y: 700, width: 400, height: 100), viewportHeight: 800))
        XCTAssertTrue(FeedGeometry.isNearBottom(
            lastRow: CGRect(x: 0, y: 840, width: 400, height: 100), viewportHeight: 800))
        // A screenful further down is not.
        XCTAssertFalse(FeedGeometry.isNearBottom(
            lastRow: CGRect(x: 0, y: 1200, width: 400, height: 100), viewportHeight: 800))
        XCTAssertFalse(FeedGeometry.isNearBottom(lastRow: nil, viewportHeight: 800))
    }

    // Why every near-bottom gate in NativeFeedView reads the row's BOTTOM and
    // not its top. A newest message TALLER than the viewport (a long code
    // block) is the case that separates them: the reader can be a screenful
    // into scroll-back and still have that row's top above the fold, so a
    // `minY < height + slack` test called them "at the bottom" and every
    // trigger keyed on it — a composer resize, a link card landing, the typing
    // bubble, a text-size change — yanked them down to the newest message.
    func testTallNewestRowDoesNotReadAsAtTheBottom() {
        let viewport: CGFloat = 800
        // One 900pt message, pinned: its bottom rests at the viewport bottom,
        // its top is far above the fold (minY = -100).
        let pinned = CGRect(x: 0, y: -100, width: 400, height: 900)
        XCTAssertTrue(FeedGeometry.isNearBottom(lastRow: pinned, viewportHeight: viewport))

        // The same row after scrolling 300pt back INTO it: still overlapping the
        // viewport, top now on screen — and emphatically not at the bottom.
        let scrolledBack = CGRect(x: 0, y: 200, width: 400, height: 900)
        XCTAssertFalse(FeedGeometry.isNearBottom(lastRow: scrolledBack, viewportHeight: viewport))
        // The reading the gates used to use would have said yes to that one.
        XCTAssertLessThan(scrolledBack.minY, viewport + 150)
    }
}