import Foundation
import Testing
@testable import Kanban

/// **Nearest-`.git`-wins, freshly at every open** (06-history-undo.md ▸ Rules ▸ Detection) — the one
/// question every git surface starts from, pinned against real directories rather than against a
/// mocked filesystem, because what it is *about* is what is on disk.
///
/// The rule has four claims and this file is one test per claim: root wins, an ancestor is nested,
/// neither is `none`, and the answer is re-derived rather than remembered — "a board can therefore
/// change mode between opens (e.g. the user ran `git init` in a terminal) — the app just reflects
/// what it finds." `BoardGitEntryProbeTests` and `BoardGitModeDenialTests` below pin the
/// 2026-08-06 axis on top of it: "Denial is not absence" — a check the sandbox refuses must read as
/// `.unverifiable`, never as `.none`.

// MARK: - Fixtures

/// A `.git` **directory** with a plausible ref inside — what `git init` leaves.
private func makeGitDirectory(at parent: URL) throws {
    let gitDirectory = parent.appendingPathComponent(".git", isDirectory: true)
    try FileManager.default.createDirectory(at: gitDirectory, withIntermediateDirectories: true)
    try Data("ref: refs/heads/main\n".utf8).write(to: gitDirectory.appendingPathComponent("HEAD"))
}

/// A `.git` **file** — what a linked worktree or a submodule leaves. Still a repository, and the
/// reason detection asks `fileExists` rather than `isDirectory`.
private func makeGitPointerFile(at parent: URL, to target: String) throws {
    try Data("gitdir: \(target)\n".utf8).write(to: parent.appendingPathComponent(".git"))
}

/// A board folder inside the fixture, so an *ancestor* can carry the repository.
private func makeSubfolder(_ fixture: WriterFixture, named name: String) throws -> URL {
    let url = fixture.root.appendingPathComponent(name, isDirectory: true)
    try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
    return url
}

// MARK: - Detection

@Suite("Board git mode ▸ detection")
struct BoardGitModeTests {

    @Test("A `.git` at the board root is git mode")
    func rootRepositoryIsGitMode() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try fixture.item("", Item.board)
        try makeGitDirectory(at: fixture.root)

        #expect(BoardGitMode.detect(boardRoot: fixture.root) == .git)
    }

    @Test("A `.git` *file* is a repository too — a worktree is not mode none")
    func aWorktreePointerIsGitMode() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try fixture.item("", Item.board)
        try makeGitPointerFile(at: fixture.root, to: "/somewhere/else/.git/worktrees/board")

        #expect(BoardGitMode.detect(boardRoot: fixture.root) == .git)
    }

    @Test("No `.git` at the root and none above it is mode none")
    func aPlainFolderIsModeNone() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try fixture.item("", Item.board)

        #expect(BoardGitMode.detect(boardRoot: fixture.root) == .none)
    }

    @Test("A `.git` at an ancestor and none at the root is repo-nested")
    func anEnclosingRepositoryIsRepoNested() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try makeGitDirectory(at: fixture.root)
        let board = try makeSubfolder(fixture, named: "project/docs/board")

        #expect(BoardGitMode.detect(boardRoot: board) == .repoNested)
        #expect(BoardGitMode.enclosingRepositoryRoot(above: board)?.standardizedFileURL
            == fixture.root.standardizedFileURL)
    }

    @Test("Nearest wins: a board with its own `.git` inside a repository is git mode, not nested")
    func theNearestRepositoryWins() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try makeGitDirectory(at: fixture.root)
        let board = try makeSubfolder(fixture, named: "board")
        try makeGitDirectory(at: board)

        #expect(BoardGitMode.detect(boardRoot: board) == .git)
    }

    @Test("The walk terminates above a board at the filesystem root, finding nothing")
    func theAncestorWalkTerminates() {
        // The one hazard this walk has ever had: NSURL-bridged URLs whose
        // `deletingLastPathComponent` grows "/.." forever instead of settling at "/". The temp
        // directory has no repository above it, so the honest answer is `nil` — reached, not hung.
        #expect(BoardGitMode.enclosingRepositoryRoot(above: URL(fileURLWithPath: "/")) == nil)
    }

    // MARK: Freshness

    @Test("Detection is re-derived at every open: a board that gains a `.git` opens in git mode next time")
    func modeChangesBetweenOpens() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try fixture.item("", Item.board)

        #expect(BoardGitMode.detect(boardRoot: fixture.root) == .none, "the first open")

        // What a user does in a terminal under a closed board.
        try makeGitDirectory(at: fixture.root)

        #expect(BoardGitMode.detect(boardRoot: fixture.root) == .git, "the next open reflects what it finds")
    }

    @Test("And a board that loses its `.git` opens back in mode none")
    func modeChangesBackBetweenOpens() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try fixture.item("", Item.board)
        try makeGitDirectory(at: fixture.root)
        #expect(BoardGitMode.detect(boardRoot: fixture.root) == .git)

        try FileManager.default.removeItem(at: fixture.root.appendingPathComponent(".git"))

        #expect(BoardGitMode.detect(boardRoot: fixture.root) == .none)
    }
}

// MARK: - Entry probe classification

/// **The errno-aware probe underneath detection** (06-history-undo.md ▸ Rules ▸ Detection, "Denial
/// is not absence", ruled 2026-07-31) — pinned directly, one test per classification, before the
/// walk that builds on it is asked to prove anything.
///
/// The `denied` cases chmod a real directory to `0o000` — tests run unprivileged, so `EACCES` is
/// genuinely reachable this way — and restore it with an explicit `defer` declared *after* the
/// fixture's own teardown defer, so it runs first (Swift's LIFO defer order):
/// `BoardDuplicatorTests.aFailedWalkRemovesThePartialSibling` is the precedent this mirrors, so a
/// failed assertion can never leave an unremovable temp directory behind.
@Suite("Board git mode ▸ entry probe")
struct BoardGitEntryProbeTests {

    @Test("A `.git` directory probes as exists")
    func probesExists() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try makeGitDirectory(at: fixture.root)

        #expect(BoardGitMode.probeGitEntry(at: fixture.root) == .exists)
        #expect(BoardGitMode.hasGitEntry(at: fixture.root), "the boolean convenience agrees")
    }

    @Test("A plain folder with no `.git` probes as absent")
    func probesAbsent() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try fixture.item("", Item.board)

        #expect(BoardGitMode.probeGitEntry(at: fixture.root) == .absent)
        #expect(!BoardGitMode.hasGitEntry(at: fixture.root))
    }

    @Test("A folder somewhere the sandbox denies traversal probes as denied, not absent")
    func probesDenied() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        let outer = fixture.root.appendingPathComponent("outer", isDirectory: true)
        let inner = outer.appendingPathComponent("inner", isDirectory: true)
        try FileManager.default.createDirectory(at: inner, withIntermediateDirectories: true)

        // Chmod the *parent*, not the probed folder itself: resolving `inner/.git` needs search
        // permission on `outer`, which a plain unix permission bit can deny for the test's own
        // unprivileged user exactly as the sandbox denies an ungranted ancestor.
        try FileManager.default.setAttributes([.posixPermissions: 0o000], ofItemAtPath: outer.path)
        defer { try? FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: outer.path) }

        #expect(BoardGitMode.probeGitEntry(at: inner) == .denied)
        #expect(!BoardGitMode.hasGitEntry(at: inner), "the boolean convenience collapses denied to false, like absent")
    }
}

// MARK: - Denial-aware detection

/// **The walk semantics denial adds** (06 ▸ Rules ▸ Detection): a denied ancestor never ends the
/// walk early, because a farther ancestor's `.git` still makes repo-nested certain; only a walk that
/// finds nothing at all *and* saw a denial along the way reads `.unverifiable`.
@Suite("Board git mode ▸ denial-aware detection")
struct BoardGitModeDenialTests {

    @Test("A denied board-root probe is unverifiable outright — the walk never runs")
    func deniedRootProbeIsUnverifiable() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        let boardRoot = fixture.root.appendingPathComponent("board", isDirectory: true)
        try FileManager.default.createDirectory(at: boardRoot, withIntermediateDirectories: true)

        try FileManager.default.setAttributes([.posixPermissions: 0o000], ofItemAtPath: boardRoot.path)
        defer { try? FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: boardRoot.path) }

        #expect(BoardGitMode.detect(boardRoot: boardRoot) == .unverifiable)
    }

    @Test("A denied ancestor with nothing found anywhere else reads unverifiable")
    func deniedAncestorWithNothingFoundIsUnverifiable() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        let blocked = fixture.root.appendingPathComponent("blocked", isDirectory: true)
        let boardRoot = blocked.appendingPathComponent("board", isDirectory: true)
        try FileManager.default.createDirectory(at: boardRoot, withIntermediateDirectories: true)

        try FileManager.default.setAttributes([.posixPermissions: 0o000], ofItemAtPath: blocked.path)
        defer { try? FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: blocked.path) }

        let walk = BoardGitMode.ancestorWalk(above: boardRoot)
        #expect(walk.root == nil)
        #expect(walk.sawDenial)
        #expect(BoardGitMode.detect(boardRoot: boardRoot) == .unverifiable)
    }

    @Test("A denied nearer ancestor never hides a `.git` on a farther one — repo-nested is certain")
    func deniedAncestorWithARepositoryFartherUpIsRepoNested() throws {
        // **A note on what chmod can and cannot simulate**: the sandbox denies a *specific path*
        // independently of the filesystem's own permission bits — an ancestor above the board's
        // grant can be denied while the board root itself, inside the grant, stays fully readable.
        // POSIX `chmod`, in contrast, cascades: removing search permission from a real ancestor
        // directory denies resolving *everything* beneath it, board root included, which is a
        // strictly stronger (and still individually honest) denial than the sandbox's. So this test
        // proves the walk's own claim directly — `ancestorWalk(above:)` never touches `boardRoot`
        // itself, only the candidates above it, and is unaffected by that cascade.
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try makeGitDirectory(at: fixture.root)
        let blocked = fixture.root.appendingPathComponent("blocked", isDirectory: true)
        let boardRoot = blocked.appendingPathComponent("board", isDirectory: true)
        try FileManager.default.createDirectory(at: boardRoot, withIntermediateDirectories: true)

        try FileManager.default.setAttributes([.posixPermissions: 0o000], ofItemAtPath: blocked.path)
        defer { try? FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: blocked.path) }

        // "A farther ancestor showing `.git` makes repo-nested certain regardless of the denied
        // nearer one — nearest-wins only affects which root you'd name, not whether one exists."
        let walk = BoardGitMode.ancestorWalk(above: boardRoot)
        #expect(walk.root?.standardizedFileURL == fixture.root.standardizedFileURL)
        #expect(walk.sawDenial, "the denial is still recorded, even though it didn't decide the outcome")

        // `detect(boardRoot:)` itself reads `.unverifiable` here — not `.repoNested` — but for the
        // cascade reason above, not because the walk's certainty claim is false: `blocked` sits
        // between the filesystem root and `boardRoot`, so chmoding it also denies **`boardRoot`'s
        // own** `.git` probe, and `detect` answers that denial before the ancestor walk ever runs
        // (06 ▸ Rules: "probe the board root's `.git` first … denied → `.unverifiable`"). A real
        // sandboxed board, whose own root sits inside the grant, would not hit this path — its own
        // probe would succeed and the walk above is what would then run and find `.repoNested`.
        #expect(BoardGitMode.detect(boardRoot: boardRoot) == .unverifiable)
    }

    @Test("All-clean paths are unaffected: none, git, and repo-nested still read as before")
    func cleanPathsAreUnaffected() throws {
        let plain = try WriterFixture()
        defer { plain.tearDown() }
        try plain.item("", Item.board)
        #expect(BoardGitMode.detect(boardRoot: plain.root) == .none)

        let gitBoard = try WriterFixture()
        defer { gitBoard.tearDown() }
        try makeGitDirectory(at: gitBoard.root)
        #expect(BoardGitMode.detect(boardRoot: gitBoard.root) == .git)

        let nested = try WriterFixture()
        defer { nested.tearDown() }
        try makeGitDirectory(at: nested.root)
        let board = try makeSubfolder(nested, named: "project/docs/board")
        #expect(BoardGitMode.detect(boardRoot: board) == .repoNested)
    }
}