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

import "forge-std/Test.sol";
import "../../contracts/core/DBISInstitutionalVault.sol";
import "../../contracts/interfaces/IVault.sol";
import "../../contracts/interfaces/IOracleAdapter.sol";

/**
 * @title DBISInstitutionalVaultTest
 * @notice Unit tests for DBIS Institutional Vault
 */
contract DBISInstitutionalVaultTest is Test {
    DBISInstitutionalVault public vault;
    address public oracleAdapter;
    address public aavePool;
    address public aaveUserAccount;
    address public owner;
    address public kernel;
    address public operator;

    event CollateralAdded(address indexed asset, uint256 amount);
    event DebtRepaid(address indexed asset, uint256 amount);
    event PositionSnapshot(
        uint256 collateralBefore,
        uint256 debtBefore,
        uint256 collateralAfter,
        uint256 debtAfter,
        uint256 healthFactorBefore,
        uint256 healthFactorAfter
    );

    function setUp() public {
        owner = address(this);
        kernel = address(0x1);
        operator = address(0x2);
        oracleAdapter = address(0x3);
        aavePool = address(0x4);
        aaveUserAccount = address(0x5);

        vault = new DBISInstitutionalVault(
            oracleAdapter,
            aavePool,
            aaveUserAccount,
            owner
        );

        vault.grantKernel(kernel);
        vault.grantOperator(operator);
    }

    function test_InitialState() public view {
        assertEq(address(vault.oracleAdapter()), oracleAdapter);
        assertEq(address(vault.aavePool()), aavePool);
        assertEq(vault.aaveUserAccount(), aaveUserAccount);
        assertTrue(vault.hasRole(vault.DEFAULT_ADMIN_ROLE(), owner));
    }

    function test_RecordCollateralAdded() public {
        address asset = address(0x100);
        uint256 amount = 1000e18;

        vm.prank(kernel);
        vm.expectEmit(true, false, false, true);
        emit CollateralAdded(asset, amount);
        vault.recordCollateralAdded(asset, amount);

        (uint256 collateral, uint256 debt) = vault.getAssetPosition(asset);
        assertEq(collateral, amount);
        assertEq(debt, 0);
    }

    function test_RecordDebtRepaid() public {
        address asset = address(0x100);
        uint256 debtAmount = 500e18;
        uint256 repayAmount = 300e18;

        // First add some debt (simulated)
        vm.startPrank(kernel);
        vault.recordCollateralAdded(asset, 1000e18);
        // Manually set debt (would need internal access or mock)
        vm.stopPrank();

        vm.prank(kernel);
        vm.expectEmit(true, false, false, true);
        emit DebtRepaid(asset, repayAmount);
        vault.recordDebtRepaid(asset, repayAmount);
    }

    function test_SnapshotPosition() public {
        vm.prank(kernel);
        (uint256 collateral, uint256 debt, uint256 hf) = vault.snapshotPosition();

        // Values would depend on Aave pool mock
        assertTrue(collateral >= 0);
        assertTrue(debt >= 0);
        assertTrue(hf >= 0);
    }

    function test_OnlyKernelCanRecord() public {
        address asset = address(0x100);
        uint256 amount = 1000e18;

        vm.prank(operator);
        vm.expectRevert();
        vault.recordCollateralAdded(asset, amount);
    }

    function test_UpdateOracleAdapter() public {
        address newOracle = address(0x200);
        
        vault.setOracleAdapter(newOracle);
        assertEq(address(vault.oracleAdapter()), newOracle);
    }

    function test_OnlyOwnerCanUpdateOracle() public {
        address newOracle = address(0x200);
        
        vm.prank(operator);
        vm.expectRevert();
        vault.setOracleAdapter(newOracle);
    }
}