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

import {Test, console} from "forge-std/Test.sol";
import {BridgeRegistry} from "../../../contracts/bridge/interop/BridgeRegistry.sol";

contract BridgeRegistryTest is Test {
    BridgeRegistry public registry;
    address public admin = address(0x1);
    address public registrar = address(0x2);
    address public token = address(0x100);

    function setUp() public {
        vm.startPrank(admin);
        registry = new BridgeRegistry(admin);
        registry.grantRole(registry.REGISTRAR_ROLE(), registrar);
        vm.stopPrank();
    }

    function test_RegisterDestination() public {
        vm.startPrank(registrar);
        registry.registerDestination(
            137, // Polygon
            "Polygon",
            128, // minFinalityBlocks
            3600, // timeoutSeconds
            10, // 0.1% baseFee
            address(0x200) // feeRecipient
        );
        vm.stopPrank();

        (
            uint256 chainId,
            string memory chainName,
            bool enabled,
            uint256 minFinalityBlocks,
            uint256 timeoutSeconds,
            uint256 baseFee,
            address feeRecipient
        ) = registry.destinations(137);
        assertEq(chainId, 137);
        assertEq(enabled, true);
        assertEq(minFinalityBlocks, 128);
    }

    function test_RegisterToken() public {
        uint256[] memory allowedDestinations = new uint256[](2);
        allowedDestinations[0] = 137; // Polygon
        allowedDestinations[1] = 10; // Optimism

        vm.startPrank(registrar);
        registry.registerDestination(137, "Polygon", 128, 3600, 10, address(0x200));
        registry.registerDestination(10, "Optimism", 1, 3600, 10, address(0x200));
        registry.registerToken(
            token,
            1 ether, // minAmount
            100 ether, // maxAmount
            allowedDestinations,
            0, // riskLevel
            5 // 0.05% bridgeFeeBps
        );
        vm.stopPrank();

        // TokenConfig struct contains dynamic array, so can't use direct getter
        // Instead, validate through validateBridgeRequest which checks the config
        (bool isValid, uint256 fee) = registry.validateBridgeRequest(token, 1 ether, 137);
        assertTrue(isValid, "Token should be registered and valid");
        assertGt(fee, 0, "Fee should be calculated");
    }

    function test_ValidateBridgeRequest() public {
        // Register destination and token first
        vm.startPrank(registrar);
        registry.registerDestination(137, "Polygon", 128, 3600, 10, address(0x200));
        
        uint256[] memory allowedDestinations = new uint256[](1);
        allowedDestinations[0] = 137;
        registry.registerToken(token, 1 ether, 100 ether, allowedDestinations, 0, 5);
        vm.stopPrank();

        // Validate request
        (bool isValid, uint256 fee) = registry.validateBridgeRequest(
            token,
            10 ether,
            137
        );

        assertTrue(isValid);
        assertGt(fee, 0);
    }

    function test_UpdateRouteHealth() public {
        vm.startPrank(registrar);
        registry.registerDestination(137, "Polygon", 128, 3600, 10, address(0x200));
        registry.updateRouteHealth(137, token, true, 300); // success, 5 min
        registry.updateRouteHealth(137, token, true, 250); // success, ~4 min
        registry.updateRouteHealth(137, token, false, 0); // failure
        vm.stopPrank();

        uint256 healthScore = registry.getRouteHealthScore(137, token);
        assertGt(healthScore, 0);
        assertLt(healthScore, 10000); // Should be less than 100% due to failure
    }

    function test_Revert_InvalidFee() public {
        vm.startPrank(registrar);
        vm.expectRevert();
        registry.registerDestination(137, "Polygon", 128, 3600, 10001, address(0x200)); // >100%
    }
}
