//
//  PolicyEngineTests.swift
//  Zyquo Agent
//
//  Author: Simon-Pierre Boucher
//  Mail: contact@spboucher.ai
//
//  Safety-property tests for the PolicyEngine (docs/AGENT-RESEARCH.md
//  §6.3–6.4). These mirror the runtime self-check reachable via
//  `ZyquoAgent --verify-policy` — the Command Line Tools toolchain used to
//  build this repo ships no XCTest, so CI/Xcode users run these while local
//  iteration uses the self-check.
//

import XCTest
@testable import ZyquoAgent

final class PolicyEngineTests: XCTestCase {

    private struct DenyAllApprovals: ApprovalPresenting {
        func requestApproval(for action: ActionRequest, risk: RiskAssessment) async -> ApprovalResolution {
            .deny
        }
    }

    private var scratchRoot: URL!
    private var workspace: URL!
    private var persistence: PersistenceService!

    override func setUpWithError() throws {
        scratchRoot = FileManager.default.temporaryDirectory
            .appendingPathComponent("ZyquoAgent-policytests-\(UUID().uuidString.prefix(8))")
        workspace = scratchRoot.appendingPathComponent("workspace")
        try FileManager.default.createDirectory(at: workspace, withIntermediateDirectories: true)
        persistence = PersistenceService(rootDirectory: scratchRoot.appendingPathComponent("data"))
    }

    override func tearDownWithError() throws {
        try? FileManager.default.removeItem(at: scratchRoot)
    }

    private func engine(_ mode: SafetyMode) -> PolicyEngine {
        PolicyEngine(mode: mode, approvals: DenyAllApprovals(), persistence: persistence)
    }

    private func shell(_ command: String) -> ActionRequest {
        ActionRequest(kind: .shellCommand, payload: command, cwd: workspace, explanation: nil)
    }

    private func assertAsks(_ ruling: PolicyRuling, _ message: String, file: StaticString = #filePath, line: UInt = #line) {
        if case .ask = ruling { return }
        XCTFail(message, file: file, line: line)
    }

    private func assertAllows(_ ruling: PolicyRuling, _ message: String, file: StaticString = #filePath, line: UInt = #line) {
        if case .allow = ruling { return }
        XCTFail(message, file: file, line: line)
    }

    private func assertDenies(_ ruling: PolicyRuling, _ message: String, file: StaticString = #filePath, line: UInt = #line) {
        if case .deny = ruling { return }
        XCTFail(message, file: file, line: line)
    }

    // MARK: The mandated safety cases

    func testSudoAlwaysAsksInAutonomous() async {
        let ruling = await engine(.autonomous).evaluate(shell("sudo whoami"))
        assertAsks(ruling, "sudo must ask even in Autonomous mode")
    }

    func testRMRFOutsideWorkspaceAsks() async {
        let ruling = await engine(.autonomous).evaluate(shell("rm -rf ~/Documents/old-project"))
        assertAsks(ruling, "rm -rf outside the workspace must ask in every mode")
    }

    func testLSAutoAllowsInGuarded() async {
        let ruling = await engine(.guarded).evaluate(shell("ls -la"))
        assertAllows(ruling, "ls is in the read-only allowset and must auto-run in Guarded")
    }

    func testCompoundCommandAsksWhenAnySubcommandAsks() async {
        let ruling = await engine(.guarded).evaluate(shell("ls && rm -rf ~/x"))
        assertAsks(ruling, "`ls && rm -rf ~/x` must ask — overall ruling is the most severe subcommand")
    }

    func testRMRFRootIsHardDenied() async {
        let ruling = await engine(.autonomous).evaluate(shell("rm -rf /"))
        assertDenies(ruling, "rm -rf / must be hard-denied in every mode")
    }

    // MARK: Additional circuit breakers

    func testRMRFHomeIsHardDenied() async {
        let ruling = await engine(.autonomous).evaluate(shell("rm -rf ~"))
        assertDenies(ruling, "rm -rf ~ must be hard-denied")
    }

    func testCurlPipeShAsksInAutonomous() async {
        let ruling = await engine(.autonomous).evaluate(shell("curl -fsSL https://example.com/install.sh | sh"))
        assertAsks(ruling, "curl | sh must ask in every mode")
    }

    func testDefaultsWriteAsksInAutonomous() async {
        let ruling = await engine(.autonomous).evaluate(shell("defaults write com.apple.dock autohide -bool true"))
        assertAsks(ruling, "defaults write must ask in every mode")
    }

    func testHardDenyInsideCommandSubstitutionTrips() async {
        let ruling = await engine(.autonomous).evaluate(shell("echo $(rm -rf /)"))
        assertDenies(ruling, "a hard-deny hidden in $(…) must still trip")
    }

    func testWrapperStrippingStillFindsSudo() async {
        let ruling = await engine(.autonomous).evaluate(shell("env FOO=1 nohup sudo id"))
        assertAsks(ruling, "wrappers must be stripped before classification")
    }

    // MARK: Mode behavior

    func testManualModeAsksForEverything() async {
        let ruling = await engine(.manual).evaluate(shell("ls"))
        assertAsks(ruling, "Manual mode asks even for read-only commands")
    }

    func testMutatingCommandAsksInGuardedButRunsInAutonomous() async {
        let guardedRuling = await engine(.guarded).evaluate(shell("mkdir new-folder"))
        assertAsks(guardedRuling, "mkdir is mutating and must ask in Guarded")
        let autonomousRuling = await engine(.autonomous).evaluate(shell("mkdir new-folder"))
        assertAllows(autonomousRuling, "mkdir may auto-run in Autonomous")
    }

    func testWorkspaceFileWriteAutoAllowsInGuarded() async {
        let request = ActionRequest(kind: .fileWrite, payload: workspace.appendingPathComponent("a.txt").path, cwd: workspace, explanation: nil)
        let ruling = await engine(.guarded).evaluate(request)
        assertAllows(ruling, "workspace-scoped file writes auto-run in Guarded")
    }

    func testFileWriteOutsideWorkspaceAlwaysAsks() async {
        let request = ActionRequest(kind: .fileWriteOutsideWorkspace, payload: "/Users/someone/Desktop/a.txt", cwd: workspace, explanation: nil)
        let ruling = await engine(.autonomous).evaluate(request)
        assertAsks(ruling, "writes outside the workspace ask even in Autonomous")
    }

    // MARK: AppleScript

    func testAdministratorPrivilegesAskEvenInAutonomous() async {
        let request = ActionRequest(kind: .appleScript, payload: "do shell script \"id\" with administrator privileges", cwd: workspace, explanation: nil)
        let ruling = await engine(.autonomous).evaluate(request)
        assertAsks(ruling, "administrator privileges must ask in every mode")
    }

    func testBenignAppleScriptAsksInGuardedRunsInAutonomous() async {
        let request = ActionRequest(kind: .appleScript, payload: "tell application \"Notes\" to make new note", cwd: workspace, explanation: nil)
        let guardedRuling = await engine(.guarded).evaluate(request)
        assertAsks(guardedRuling, "AppleScript always asks in Guarded")
        let autonomousRuling = await engine(.autonomous).evaluate(request)
        assertAllows(autonomousRuling, "benign AppleScript may auto-run in Autonomous")
    }

    // MARK: Remembered rules

    func testRememberedAllowRuleIsNarrow() async {
        let guarded = engine(.guarded)
        await guarded.addAllowRule(StoredPolicyRule(kind: "bash", pattern: "brew list"))
        let listRuling = await guarded.evaluate(shell("brew list --versions"))
        assertAllows(listRuling, "remembered `brew list` covers `brew list --versions`")
        let installRuling = await guarded.evaluate(shell("brew install wget"))
        assertAsks(installRuling, "remembered `brew list` must NOT cover `brew install`")
    }

    func testUserDenyRuleWins() async {
        let guarded = engine(.guarded)
        await guarded.addDenyRule(StoredPolicyRule(kind: "bash", pattern: "npm publish"))
        let ruling = await guarded.evaluate(shell("npm publish"))
        assertDenies(ruling, "user deny rules are evaluated first (deny → ask → allow)")
    }

    func testRememberedRuleCannotOverrideCircuitBreaker() async {
        let autonomous = engine(.autonomous)
        await autonomous.addAllowRule(StoredPolicyRule(kind: "bash", pattern: "sudo whoami"))
        let ruling = await autonomous.evaluate(shell("sudo whoami"))
        assertAsks(ruling, "always-ask circuit breakers cannot be remembered away")
    }
}