// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import { TestBase } from "./TestBase.sol";
import {
    PinnedKYAAdapterV3,
    PinnedERC8004AdapterV3,
    PinnedERC8004ValidationAdapterV3,
    PinnedERC8004ReputationAdapterV3,
    PinnedReadAdapterV3
} from "../src/PinnedTrustAdaptersV3.sol";

contract TrustRegistryMock {
    bool public registered;
    bool public active;
    bool public authorized;

    function set(bool registered_, bool active_, bool authorized_) external {
        registered = registered_;
        active = active_;
        authorized = authorized_;
    }

    function isRegistered(address) external view returns (bool) {
        return registered;
    }

    function registeredAt(address) external pure returns (uint64) {
        return 1234;
    }

    function agentType(address) external pure returns (string memory) {
        return "test-agent";
    }

    function isActive(uint256) external view returns (bool) {
        return active;
    }

    function isAuthorizedOperator(uint256, address) external view returns (bool) {
        return authorized;
    }

    function validationStatus(uint256, bytes32) external pure returns (bool, bytes32, uint64) {
        return (false, keccak256("evidence"), 5678);
    }

    function reputationRecord(uint256, bytes32) external pure returns (int256, uint64, bytes32) {
        return (-7, 9012, keccak256("reputation-evidence"));
    }
}

contract MalformedTrustRegistry {
    fallback() external {
        assembly {
            mstore(0, 1)
            return(0, 1)
        }
    }
}

contract RevertingTrustRegistry {
    fallback() external {
        revert("unavailable");
    }
}

contract PinnedTrustAdaptersTest is TestBase {
    TrustRegistryMock internal registry;

    function setUp() public {
        registry = new TrustRegistryMock();
    }

    function testPinnedAdaptersReturnInformationalValuesIncludingFalseAndNegative() public {
        PinnedKYAAdapterV3 kya = new PinnedKYAAdapterV3(address(registry), address(registry).codehash);
        PinnedERC8004AdapterV3 identity = new PinnedERC8004AdapterV3(address(registry), address(registry).codehash);
        PinnedERC8004ValidationAdapterV3 validation =
            new PinnedERC8004ValidationAdapterV3(address(registry), address(registry).codehash);
        PinnedERC8004ReputationAdapterV3 reputation =
            new PinnedERC8004ReputationAdapterV3(address(registry), address(registry).codehash);

        (bool registered, uint64 since, string memory kind) = kya.resolve(address(this));
        assertFalse(registered);
        assertEq(since, 0);
        assertEq(keccak256(bytes(kind)), keccak256(bytes("")));
        (bool active, bool authorized) = identity.identity(1, address(this));
        assertFalse(active);
        assertFalse(authorized);
        (bool valid, bytes32 evidenceHash, uint64 updatedAt) = validation.validation(1, keccak256("validation"));
        assertFalse(valid);
        assertEq(evidenceHash, keccak256("evidence"));
        assertEq(updatedAt, 5678);
        (int256 value, uint64 reputationUpdatedAt, bytes32 evidenceRoot) =
            reputation.reputation(1, keccak256("namespace"));
        assertTrue(value == -7);
        assertEq(reputationUpdatedAt, 9012);
        assertEq(evidenceRoot, keccak256("reputation-evidence"));
        assertEq(
            keccak256(bytes(kya.decisionSemantics())),
            keccak256(
                bytes(
                    "informational-only; MUST NOT grant custody, access, eligibility, pricing, routing, slashing, or settlement"
                )
            )
        );

        registry.set(true, true, true);
        (registered, since, kind) = kya.resolve(address(this));
        assertTrue(registered);
        assertEq(since, 1234);
        assertEq(keccak256(bytes(kind)), keccak256(bytes("test-agent")));
    }

    function testConstructionRejectsWrongCodehashAndRuntimeChangeFailsClosed() public {
        vm.expectRevert(PinnedReadAdapterV3.InvalidRegistry.selector);
        new PinnedKYAAdapterV3(address(registry), bytes32(uint256(1)));

        PinnedKYAAdapterV3 kya = new PinnedKYAAdapterV3(address(registry), address(registry).codehash);
        vm.etch(address(registry), hex"60006000fd");
        vm.expectRevert(PinnedReadAdapterV3.InvalidRegistry.selector);
        kya.resolve(address(this));
    }

    function testMalformedAndRevertingRegistriesFailClosed() public {
        MalformedTrustRegistry malformed = new MalformedTrustRegistry();
        PinnedERC8004AdapterV3 malformedAdapter =
            new PinnedERC8004AdapterV3(address(malformed), address(malformed).codehash);
        vm.expectRevert();
        malformedAdapter.identity(1, address(this));

        RevertingTrustRegistry revertingTarget = new RevertingTrustRegistry();
        PinnedERC8004ValidationAdapterV3 revertingAdapter =
            new PinnedERC8004ValidationAdapterV3(address(revertingTarget), address(revertingTarget).codehash);
        vm.expectRevert();
        revertingAdapter.validation(1, keccak256("validation"));
    }
}