import Foundation
import Testing
@testable import Kanban

/// **Where the app's commits get their author from** (06-history-undo.md ▸ Interaction with external
/// writers ▸ "Where the user's git identity comes from"): repo-local `.git/config` when it names
/// one, the derived `Full Name <shortname@hostname>` default when it doesn't.
///
/// Both halves are pure functions here on purpose. The derivation takes its three strings as
/// arguments rather than reading the machine, so the *shape* is provable on any machine — including
/// one whose account has no full name, which is the case the fallbacks exist for. And the config
/// read is a parse over text, so the format's edges (comments, quoting, subsections, a `[user]`
/// section that never appears) are pinned without a repository.

@Suite("Git identity ▸ the derived default")
struct GitIdentityDerivationTests {

    @Test("The shape is the account's full name plus shortname@hostname")
    func theDerivedShape() {
        let identity = GitIdentity.derived(fullName: "Ada Lovelace", accountName: "ada", hostName: "analytical.local")

        #expect(identity.name == "Ada Lovelace")
        #expect(identity.email == "ada@analytical.local")
    }

    @Test("An account with no full name falls back to its short name rather than committing as \"\"")
    func anEmptyFullNameFallsBack() {
        let identity = GitIdentity.derived(fullName: "   ", accountName: "ada", hostName: "analytical.local")

        #expect(identity.name == "ada")
        #expect(identity.email == "ada@analytical.local")
    }

    @Test("Characters an address may not carry are collapsed, not passed to libgit2")
    func addressComponentsAreSanitized() {
        // libgit2 refuses a signature carrying a space or an angle bracket outright — the commit
        // fails rather than looking odd — so this is a correctness fallback, not cosmetics.
        let identity = GitIdentity.derived(
            fullName: "Ada Lovelace",
            accountName: "ada lovelace",
            hostName: "Ada's <Mac>.local"
        )

        #expect(!identity.email.contains(" "))
        #expect(!identity.email.contains("<"))
        #expect(!identity.email.contains(">"))
        #expect(identity.email == "ada-lovelace@Ada-s--Mac-.local")
    }

    @Test("A machine with no name reads localhost, and an account with none reads user")
    func emptyComponentsHaveHonestFallbacks() {
        let identity = GitIdentity.derived(fullName: "", accountName: "", hostName: "")

        #expect(identity.name == "Lanework")
        #expect(identity.email == "user@localhost")
    }

    @Test("A trailing dot on a fully-qualified host name is dropped")
    func aTrailingDotIsDropped() {
        let identity = GitIdentity.derived(fullName: "Ada", accountName: "ada", hostName: "host.example.com.")

        #expect(identity.email == "ada@host.example.com")
    }

    @Test("This machine's derived default is well-formed, whatever this machine is called")
    func theMachineDefaultIsWellFormed() {
        let identity = GitIdentity.derivedDefault()

        #expect(!identity.name.isEmpty)
        #expect(identity.email.contains("@"))
        #expect(!identity.email.contains(" "))
    }
}

@Suite("Git identity ▸ repo-local config wins")
struct GitConfigFileTests {

    @Test("A `[user]` section supplies both halves")
    func bothKeysAreRead() {
        let text = """
        [core]
        \trepositoryformatversion = 0
        [user]
        \tname = Ada Lovelace
        \temail = ada@example.com
        """

        let identity = GitConfigFile.identity(inConfigText: text)
        #expect(identity.name == "Ada Lovelace")
        #expect(identity.email == "ada@example.com")
    }

    @Test("Config wins over the derived default, key by key")
    func resolutionPrefersConfigPerKey() {
        let derived = GitIdentity(name: "Machine Owner", email: "owner@mac.local")

        let both = GitIdentity.resolve(repoLocal: (name: "Ada", email: "ada@example.com"), derived: derived)
        #expect(both == GitIdentity(name: "Ada", email: "ada@example.com"))

        // Half-configured is a real state — it is what a `git config user.email` typo leaves — and
        // git resolves each key on its own.
        let nameOnly = GitIdentity.resolve(repoLocal: (name: "Ada", email: nil), derived: derived)
        #expect(nameOnly == GitIdentity(name: "Ada", email: "owner@mac.local"))

        let neither = GitIdentity.resolve(repoLocal: (name: nil, email: "  "), derived: derived)
        #expect(neither == derived, "a blank value is not a value")
    }

    @Test("Comments and quoting are read the way git reads them")
    func theParseHandlesTheFormatsEdges() {
        let text = """
        # a comment
        ; another
        [user]
        \tname = "Ada # Lovelace"
        \temail = ada@example.com # trailing comment
        """

        let identity = GitConfigFile.identity(inConfigText: text)
        #expect(identity.name == "Ada # Lovelace", "a `#` inside quotes is content")
        #expect(identity.email == "ada@example.com", "an unquoted trailing comment is not")
    }

    @Test("Reads take the last plain-section value, and no subsection's")
    func readsTakeTheLastPlainSectionValue() {
        // **Writes append, reads take the last** (06 ▸ Interaction with external writers, blessed
        // 2026-07-31): "the reader — like git itself — takes the last plain-section value, which is
        // exactly what an append produces."
        let appended = """
        [user]
        \tname = Old Ada
        \temail = old@example.com
        [user]
        \tname = New Ada
        \temail = new@example.com
        """
        #expect(GitConfigFile.identity(inConfigText: appended).name == "New Ada")
        #expect(GitConfigFile.identity(inConfigText: appended).email == "new@example.com")

        // A subsection is a *different key* in git's model — `user.work.name`, not `user.name` — so
        // it is not an answer to this question however late in the file it sits. Signing the user's
        // commits with an identity they filed under a name this app never asked about would be the
        // worse error, and 06 says plain-section for exactly that reason.
        let subsectioned = """
        [user]
        \tname = Ada
        \temail = ada@example.com
        [user "work"]
        \tname = Work Ada
        \temail = ada@work.example
        """
        #expect(GitConfigFile.identity(inConfigText: subsectioned).name == "Ada")
        #expect(GitConfigFile.identity(inConfigText: subsectioned).email == "ada@example.com")

        // A file with *only* a subsection names nobody, and falls through to the derived default.
        let onlySubsection = "[user \"work\"]\n\tname = Work Ada\n\temail = ada@work.example\n"
        #expect(GitConfigFile.identity(inConfigText: onlySubsection) == (nil, nil))
    }

    @Test("A config with no `[user]` section, or no config at all, names nobody")
    func absentConfigNamesNobody() throws {
        let empty = GitConfigFile.identity(inConfigText: "[core]\n\tbare = false\n")
        #expect(empty.name == nil)
        #expect(empty.email == nil)

        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        let missing = GitConfigFile.identity(inGitDirectory: fixture.root.appendingPathComponent(".git"))
        #expect(missing.name == nil)
        #expect(missing.email == nil)
    }

    @Test("The file on disk is what is read — the board root's own `.git/config`")
    func theFileIsRead() throws {
        let fixture = try WriterFixture()
        defer { fixture.tearDown() }
        try fixture.file(".git/config", Data("[user]\n\tname = Ada\n\temail = ada@example.com\n".utf8))

        let identity = GitConfigFile.identity(inGitDirectory: fixture.root.appendingPathComponent(".git"))
        #expect(identity.name == "Ada")
        #expect(identity.email == "ada@example.com")
    }
}