// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "forge-std/Test.sol";
import "../../contracts/registry/UniversalAssetRegistry.sol";
import "../../contracts/bridge/UniversalCCIPBridge.sol";
import "../../contracts/bridge/BridgeOrchestrator.sol";
import "../../contracts/governance/GovernanceController.sol";

/**
 * @title UniversalBridge Integration Tests
 * @notice Comprehensive tests for all asset types through full bridge flow
 */
contract UniversalBridgeTest is Test {
    UniversalAssetRegistry public registry;
    UniversalCCIPBridge public bridge;
    BridgeOrchestrator public orchestrator;
    GovernanceController public governance;
    
    address public admin;
    address public user1;
    address public user2;
    address public mockCCIPRouter;
    
    function setUp() public {
        admin = makeAddr("admin");
        user1 = makeAddr("user1");
        user2 = makeAddr("user2");
        mockCCIPRouter = makeAddr("ccipRouter");
        
        vm.startPrank(admin);
        
        // Deploy core contracts
        registry = new UniversalAssetRegistry();
        registry.initialize(admin);
        
        governance = new GovernanceController();
        governance.initialize(address(registry), admin);
        
        bridge = new UniversalCCIPBridge();
        bridge.initialize(address(registry), mockCCIPRouter, admin);
        
        orchestrator = new BridgeOrchestrator();
        orchestrator.initialize(address(registry), address(bridge), admin);
        
        vm.stopPrank();
    }

    function testRegisterStandardERC20() public {
        vm.startPrank(admin);
        
        address mockToken = makeAddr("mockToken");
        vm.etch(mockToken, hex"00"); // Give it code
        
        bytes32 proposalId = registry.proposeAsset(
            mockToken,
            UniversalAssetRegistry.AssetType.ERC20Standard,
            UniversalAssetRegistry.ComplianceLevel.Public,
            "Test Token",
            "TEST",
            18,
            "US",
            50, // Medium volatility
            1e15,
            1000000e18
        );
        
        assertEq(uint256(proposalId), 0, "Proposal should be non-zero");
        
        vm.stopPrank();
    }

    function testGovernanceFlow() public {
        vm.startPrank(admin);
        
        // Add validator
        registry.addValidator(user1);
        
        // Create proposal
        address mockToken = makeAddr("mockToken2");
        vm.etch(mockToken, hex"00");
        
        bytes32 proposalId = registry.proposeAsset(
            mockToken,
            UniversalAssetRegistry.AssetType.Stablecoin,
            UniversalAssetRegistry.ComplianceLevel.Public,
            "Stablecoin",
            "STBL",
            6,
            "US",
            10,
            100e6,
            10000000e6
        );
        
        vm.stopPrank();
        
        // Vote on proposal
        vm.prank(user1);
        registry.voteOnProposal(proposalId, true);
        
        // Fast forward time
        vm.warp(block.timestamp + 2 days);
        
        // Execute proposal
        vm.prank(admin);
        registry.executeProposal(proposalId);
        
        // Verify asset registered
        assertTrue(registry.isAssetActive(mockToken), "Asset should be active");
    }

    function testBridgeExecution() public {
        // Test would bridge a token through the full flow
        // This requires mock CCIP router and token contracts
    }

    function testPMMIntegration() public {
        // Test PMM liquidity provision during bridge
    }

    function testComplianceChecks() public {
        // Test compliance verification for different asset types
    }
}