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

import {Test, console} from "forge-std/Test.sol";
import {CCIPSender} from "../../contracts/ccip/CCIPSender.sol";
import {CCIPReceiver} from "../../contracts/ccip/CCIPReceiver.sol";
import {IRouterClient} from "../../contracts/ccip/IRouterClient.sol";

contract CCIPErrorHandlingTest is Test {
    CCIPSender public sender;
    CCIPReceiver public receiver;
    address public mockRouter;
    address public linkToken;
    
    uint64 constant TARGET_CHAIN_SELECTOR = 5009297550715157269;
    
    function setUp() public {
        mockRouter = address(new MockRouter());
        linkToken = address(new MockLinkToken());
        address oracleAggregator = address(this); // Use test contract as aggregator
        
        sender = new CCIPSender(mockRouter, oracleAggregator, linkToken);
        receiver = new CCIPReceiver(mockRouter, oracleAggregator);
        
        MockLinkToken(linkToken).mint(address(sender), 1000e18);
        // Fund aggregator (test contract) with LINK - aggregator pays fees
        MockLinkToken(linkToken).mint(address(this), 1000e18);
    }
    
    function testInvalidMessageFormat() public {
        bytes memory invalidData = "invalid";
        
        IRouterClient.Any2EVMMessage memory message = IRouterClient.Any2EVMMessage({
            messageId: keccak256("test"),
            sourceChainSelector: 138,
            sender: abi.encode(address(sender)),
            data: invalidData,
            tokenAmounts: new IRouterClient.TokenAmount[](0)
        });
        
        vm.prank(mockRouter);
        // Should handle invalid format gracefully
        try receiver.ccipReceive(message) {
            // If it doesn't revert, that's also acceptable if error handling is implemented
        } catch {
            // Expected to revert on invalid format
        }
    }
    
    function testUnauthorizedSender() public {
        bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
        
        IRouterClient.Any2EVMMessage memory message = IRouterClient.Any2EVMMessage({
            messageId: keccak256("test"),
            sourceChainSelector: 138,
            sender: abi.encode(address(0x123)), // Unauthorized sender
            data: messageData,
            tokenAmounts: new IRouterClient.TokenAmount[](0)
        });
        
        vm.prank(mockRouter);
        // Should reject unauthorized sender
        receiver.ccipReceive(message);
    }
    
    function testRouterOnlyAccess() public {
        bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
        
        IRouterClient.Any2EVMMessage memory message = IRouterClient.Any2EVMMessage({
            messageId: keccak256("test"),
            sourceChainSelector: 138,
            sender: abi.encode(address(sender)),
            data: messageData,
            tokenAmounts: new IRouterClient.TokenAmount[](0)
        });
        
        // Try to call from non-router address
        vm.expectRevert("CCIPReceiver: only router");
        receiver.ccipReceive(message);
    }
    
    function testInsufficientLinkBalance() public {
        // Add destination first
        sender.addDestination(TARGET_CHAIN_SELECTOR, address(receiver));
        
        // Drain aggregator's LINK balance
        MockLinkToken(linkToken).transfer(address(0xdead), 1000e18);
        
        bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
        
        // Should revert due to insufficient balance
        vm.expectRevert();
        sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, 25000000000, 1, block.timestamp);
    }
}

contract MockRouter {
    function send(uint64, bytes memory) external pure returns (bytes32) {
        return bytes32(0);
    }
}

contract MockLinkToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    
    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }
    
    function transfer(address to, uint256 amount) external returns (bool) {
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }
    
    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(balanceOf[from] >= amount, "Insufficient balance");
        require(allowance[from][msg.sender] >= amount, "Insufficient allowance");
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        allowance[from][msg.sender] -= amount;
        return true;
    }
    
    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }
}

