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

import {Test} from "forge-std/Test.sol";
import {BaskVault} from "src/BaskVault.sol";

contract LockoutFactory {
    mapping(bytes32 => address) public tokenAddress;

    function register(bytes32 id, address token) external {
        tokenAddress[id] = token;
    }
}

contract LockoutFeed {
    uint8 public constant decimals = 8;
    address public constant aggregator = address(1);
    int256 public answer = 100e8;
    uint256 public updatedAt;

    constructor() {
        updatedAt = block.timestamp;
    }

    function set(int256 answer_, uint256 time_) external {
        answer = answer_;
        updatedAt = time_;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

contract LockoutStock {
    bytes32 public uid;
    uint8 public constant decimals = 18;
    bool public constant oraclePaused = false;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(bytes32 id) {
        uid = id;
    }

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function confiscate(address from, uint256 amount) external {
        balanceOf[from] -= amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// Once NAV is 0 while the 1e15 shares locked at 0xdEaD keep totalSupply > 0, deposits are impossible forever.
contract ZeroNavLockoutTest is Test {
    address internal constant OWNER = 0x30B57ECf51D19ABcED7F6f70974e6fBb6f3b9Da3;
    address internal constant GUARDIAN = 0x5ed39AF86f2C00ad99913B5d727bD68f2A904B68;
    address internal constant ALICE = address(0xA11CE);
    address internal constant BOB = address(0xB0B);
    uint256 internal constant MONDAY = 1_728_259_200; // 2024-10-07 00:00 UTC

    BaskVault internal vault;
    LockoutFactory internal factory;
    LockoutStock[] internal stocks;
    LockoutFeed[] internal feeds;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(MONDAY + 55800);
        vault = new BaskVault(OWNER, GUARDIAN);
        LockoutFactory template = new LockoutFactory();
        vm.etch(vault.STOCK_FACTORY(), address(template).code);
        factory = LockoutFactory(vault.STOCK_FACTORY());
        for (uint256 i; i < 4; ++i) {
            LockoutStock stock = new LockoutStock(bytes32(i + 1));
            LockoutFeed feed = new LockoutFeed();
            factory.register(stock.uid(), address(stock));
            stocks.push(stock);
            feeds.push(feed);
            stock.mint(ALICE, 1_000e18);
            stock.mint(BOB, 1_000e18);
            vm.prank(ALICE);
            stock.approve(address(vault), type(uint256).max);
            vm.prank(BOB);
            stock.approve(address(vault), type(uint256).max);
            vm.prank(OWNER);
            vault.proposeAsset(address(stock), address(feed));
        }
        vm.prank(OWNER);
        vault.finalizeGenesis();
        vm.warp(block.timestamp + 72 hours);
        _refresh();
    }

    function _refresh() internal {
        for (uint256 i; i < feeds.length; ++i) {
            feeds[i].set(100e8, block.timestamp);
        }
    }

    function _nextMarketOpen(uint256 from) internal pure returns (uint256 t) {
        t = from / 86400 * 86400 + 55800;
        if (t <= from) t += 1 days;
        while ((t / 86400 + 4) % 7 == 0 || (t / 86400 + 4) % 7 == 6) t += 1 days;
    }

    function testDepositsRecoverAfterOnlyHeldAssetIsRetiredAndRedeemed() public {
        // 1. Alice makes the only deposit: 10 stock-0 at $100 -> NAV $1,000.
        vm.prank(ALICE);
        vault.deposit(address(stocks[0]), 10e18, ALICE, 0, block.timestamp);
        assertEq(vault.balanceOf(address(0xdEaD)), 1e15);

        // 2. Owner closes and retires stock-0 (the only held asset).
        vm.startPrank(OWNER);
        vault.closeAsset(address(stocks[0]));
        uint256 id = vault.proposeRetire(address(stocks[0]));
        vm.stopPrank();
        vm.warp(block.timestamp + 7 days);
        vault.executeProposal(id);

        // 3. Alice redeems all of her shares; the retired token is still paid out to her.
        uint256 aliceShares = vault.balanceOf(ALICE);
        vm.prank(ALICE);
        vault.redeem(aliceShares, new uint256[](0), block.timestamp);
        assertEq(vault.totalSupply(), 1e15, "only the dead shares remain");
        assertEq(vault.balanceOf(ALICE), 0);

        // 4. Next market open, every feed fresh, nothing short: a new depositor must be able to deposit.
        vm.warp(_nextMarketOpen(block.timestamp));
        _refresh();
        (BaskVault.Reason reason, address fault) = vault.depositStatus(address(stocks[1]));
        assertEq(uint256(reason), uint256(BaskVault.Reason.OK), "depositStatus must not report ZeroNAV");
        assertEq(fault, address(0));
        vm.prank(BOB);
        uint256 shares = vault.deposit(address(stocks[1]), 10e18, BOB, 0, block.timestamp);
        assertGt(shares, 0, "deposit must mint shares to the new depositor");
    }

    function testDepositsRecoverAfterTotalLossIsRecognised() public {
        vm.prank(ALICE);
        vault.deposit(address(stocks[0]), 10e18, ALICE, 0, block.timestamp);
        // The whole position is confiscated at the token and the loss is recognised by the spec'd process.
        stocks[0].confiscate(address(vault), 10e18);
        assertEq(stocks[0].balanceOf(address(vault)), 0);
        vault.flagDeficit(address(stocks[0]));
        vm.warp(block.timestamp + 7 days);
        vault.recognizeLoss(address(stocks[0]));
        assertEq(vault.managed(address(stocks[0])), 0);

        vm.warp(_nextMarketOpen(block.timestamp));
        _refresh();
        (BaskVault.Reason reason,) = vault.depositStatus(address(stocks[1]));
        assertEq(uint256(reason), uint256(BaskVault.Reason.OK), "depositStatus must not report ZeroNAV");
        vm.prank(BOB);
        uint256 shares = vault.deposit(address(stocks[1]), 10e18, BOB, 0, block.timestamp);
        assertGt(shares, 0, "deposit must mint shares to the new depositor");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {BaskVault} from "src/BaskVault.sol";

contract BandFactory {
    mapping(bytes32 => address) public tokenAddress;

    function register(bytes32 id, address token) external {
        tokenAddress[id] = token;
    }
}

contract BandFeed {
    uint8 public constant decimals = 8;
    address public constant aggregator = address(1);
    int256 public answer = 100e8;
    uint256 public updatedAt;

    constructor() {
        updatedAt = block.timestamp;
    }

    function set(int256 answer_, uint256 time_) external {
        answer = answer_;
        updatedAt = time_;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

contract BandStock {
    bytes32 public uid;
    uint8 public constant decimals = 18;
    bool public constant oraclePaused = false;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(bytes32 id) {
        uid = id;
    }

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// A Band proposal executed by anyone while the feed prints a 1000x outlier re-centres the band on
/// the outlier. A deposit priced at that outlier then redeems a large slice of the other holders' assets.
contract BandRecentreProofTest is Test {
    address internal constant OWNER = 0x30B57ECf51D19ABcED7F6f70974e6fBb6f3b9Da3;
    address internal constant GUARDIAN = 0x5ed39AF86f2C00ad99913B5d727bD68f2A904B68;
    address internal constant ALICE = address(0xA11CE);
    address internal constant EVE = address(0xE0E);
    uint256 internal constant MONDAY = 1_728_259_200; // 2024-10-07 00:00 UTC

    BaskVault internal vault;
    BandStock[] internal stocks;
    BandFeed[] internal feeds;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(MONDAY + 55800);
        vault = new BaskVault(OWNER, GUARDIAN);
        BandFactory template = new BandFactory();
        vm.etch(vault.STOCK_FACTORY(), address(template).code);
        BandFactory factory = BandFactory(vault.STOCK_FACTORY());
        for (uint256 i; i < 4; ++i) {
            BandStock stock = new BandStock(bytes32(i + 1));
            BandFeed feed = new BandFeed();
            factory.register(stock.uid(), address(stock));
            stocks.push(stock);
            feeds.push(feed);
            stock.mint(ALICE, 1_000e18);
            stock.mint(EVE, 1e18);
            vm.prank(ALICE);
            stock.approve(address(vault), type(uint256).max);
            vm.prank(EVE);
            stock.approve(address(vault), type(uint256).max);
            vm.prank(OWNER);
            vault.proposeAsset(address(stock), address(feed));
        }
        vm.prank(OWNER);
        vault.finalizeGenesis();
        vm.warp(block.timestamp + 72 hours); // Thursday 15:30 UTC
        _refresh();
    }

    function _refresh() internal {
        for (uint256 i; i < feeds.length; ++i) {
            feeds[i].set(100e8, block.timestamp);
        }
    }

    function testExecutorCannotRecentreBandOnOutlierAndDrainHolders() public {
        // Alice holds 240 of each of assets 1..3 (NAV $72,000); asset 0 is unheld.
        for (uint256 i = 1; i < 4; ++i) {
            vm.prank(ALICE);
            vault.deposit(address(stocks[i]), 240e18, ALICE, 0, block.timestamp);
        }
        vm.prank(OWNER);
        uint256 id = vault.proposeBand(address(stocks[0]));
        vm.warp(block.timestamp + 7 days); // Thursday 15:30 UTC, market open
        _refresh();
        feeds[0].set(100_000e8, block.timestamp); // one 1000x outlier round, fresh

        // The outlier is outside the band [25e8, 400e8] one block earlier.
        (BaskVault.Reason before,) = vault.depositStatus(address(stocks[0]));
        assertEq(uint256(before), uint256(BaskVault.Reason.OutsideBand));

        vm.startPrank(EVE);
        (bool executed,) = address(vault).call(abi.encodeCall(vault.executeProposal, (id)));
        if (executed) {
            (bool deposited, bytes memory ret) = address(vault).call(
                abi.encodeCall(vault.deposit, (address(stocks[0]), 0.25e18, EVE, 0, block.timestamp))
            );
            if (deposited) {
                uint256 shares = abi.decode(ret, (uint256));
                vault.redeem(shares, new uint256[](0), block.timestamp);
            }
        }
        vm.stopPrank();

        // Eve paid 0.25 token0 (~$25 at the honest price). She must not walk away with other holders' assets.
        assertLt(stocks[1].balanceOf(EVE), 1e18, "band re-centred on an outlier let a depositor drain holders");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {BaskVault} from "src/BaskVault.sol";

contract LockoutFactory {
    mapping(bytes32 => address) public tokenAddress;

    function register(bytes32 id, address token) external {
        tokenAddress[id] = token;
    }
}

contract LockoutFeed {
    uint8 public constant decimals = 8;
    address public constant aggregator = address(1);
    int256 public answer = 100e8;
    uint256 public updatedAt;

    constructor() {
        updatedAt = block.timestamp;
    }

    function set(int256 answer_, uint256 time_) external {
        answer = answer_;
        updatedAt = time_;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

contract LockoutStock {
    bytes32 public uid;
    uint8 public constant decimals = 18;
    bool public constant oraclePaused = false;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(bytes32 id) {
        uid = id;
    }

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function confiscate(address from, uint256 amount) external {
        balanceOf[from] -= amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// Once NAV is 0 while the 1e15 shares locked at 0xdEaD keep totalSupply > 0, deposits are impossible forever.
contract ZeroNavLockoutTest is Test {
    address internal constant OWNER = 0x30B57ECf51D19ABcED7F6f70974e6fBb6f3b9Da3;
    address internal constant GUARDIAN = 0x5ed39AF86f2C00ad99913B5d727bD68f2A904B68;
    address internal constant ALICE = address(0xA11CE);
    address internal constant BOB = address(0xB0B);
    uint256 internal constant MONDAY = 1_728_259_200; // 2024-10-07 00:00 UTC

    BaskVault internal vault;
    LockoutFactory internal factory;
    LockoutStock[] internal stocks;
    LockoutFeed[] internal feeds;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(MONDAY + 55800);
        vault = new BaskVault(OWNER, GUARDIAN);
        LockoutFactory template = new LockoutFactory();
        vm.etch(vault.STOCK_FACTORY(), address(template).code);
        factory = LockoutFactory(vault.STOCK_FACTORY());
        for (uint256 i; i < 4; ++i) {
            LockoutStock stock = new LockoutStock(bytes32(i + 1));
            LockoutFeed feed = new LockoutFeed();
            factory.register(stock.uid(), address(stock));
            stocks.push(stock);
            feeds.push(feed);
            stock.mint(ALICE, 1_000e18);
            stock.mint(BOB, 1_000e18);
            vm.prank(ALICE);
            stock.approve(address(vault), type(uint256).max);
            vm.prank(BOB);
            stock.approve(address(vault), type(uint256).max);
            vm.prank(OWNER);
            vault.proposeAsset(address(stock), address(feed));
        }
        vm.prank(OWNER);
        vault.finalizeGenesis();
        vm.warp(block.timestamp + 72 hours);
        _refresh();
    }

    function _refresh() internal {
        for (uint256 i; i < feeds.length; ++i) {
            feeds[i].set(100e8, block.timestamp);
        }
    }

    function _nextMarketOpen(uint256 from) internal pure returns (uint256 t) {
        t = from / 86400 * 86400 + 55800;
        if (t <= from) t += 1 days;
        while ((t / 86400 + 4) % 7 == 0 || (t / 86400 + 4) % 7 == 6) t += 1 days;
    }

    function testDepositsRecoverAfterOnlyHeldAssetIsRetiredAndRedeemed() public {
        // 1. Alice makes the only deposit: 10 stock-0 at $100 -> NAV $1,000.
        vm.prank(ALICE);
        vault.deposit(address(stocks[0]), 10e18, ALICE, 0, block.timestamp);
        assertEq(vault.balanceOf(address(0xdEaD)), 1e15);

        // 2. Owner closes and retires stock-0 (the only held asset).
        vm.startPrank(OWNER);
        vault.closeAsset(address(stocks[0]));
        uint256 id = vault.proposeRetire(address(stocks[0]));
        vm.stopPrank();
        vm.warp(block.timestamp + 7 days);
        vault.executeProposal(id);

        // 3. Alice redeems all of her shares; the retired token is still paid out to her.
        uint256 aliceShares = vault.balanceOf(ALICE);
        vm.prank(ALICE);
        vault.redeem(aliceShares, new uint256[](0), block.timestamp);
        assertEq(vault.totalSupply(), 1e15, "only the dead shares remain");
        assertEq(vault.balanceOf(ALICE), 0);

        // 4. Next market open, every feed fresh, nothing short: a new depositor must be able to deposit.
        vm.warp(_nextMarketOpen(block.timestamp));
        _refresh();
        (BaskVault.Reason reason, address fault) = vault.depositStatus(address(stocks[1]));
        assertEq(uint256(reason), uint256(BaskVault.Reason.OK), "depositStatus must not report ZeroNAV");
        assertEq(fault, address(0));
        vm.prank(BOB);
        uint256 shares = vault.deposit(address(stocks[1]), 10e18, BOB, 0, block.timestamp);
        assertGt(shares, 0, "deposit must mint shares to the new depositor");
    }

    function testDepositsRecoverAfterTotalLossIsRecognised() public {
        vm.prank(ALICE);
        vault.deposit(address(stocks[0]), 10e18, ALICE, 0, block.timestamp);
        // The whole position is confiscated at the token and the loss is recognised by the spec'd process.
        stocks[0].confiscate(address(vault), 10e18);
        assertEq(stocks[0].balanceOf(address(vault)), 0);
        vault.flagDeficit(address(stocks[0]));
        vm.warp(block.timestamp + 7 days);
        vault.recognizeLoss(address(stocks[0]));
        assertEq(vault.managed(address(stocks[0])), 0);

        vm.warp(_nextMarketOpen(block.timestamp));
        _refresh();
        (BaskVault.Reason reason,) = vault.depositStatus(address(stocks[1]));
        assertEq(uint256(reason), uint256(BaskVault.Reason.OK), "depositStatus must not report ZeroNAV");
        vm.prank(BOB);
        uint256 shares = vault.deposit(address(stocks[1]), 10e18, BOB, 0, block.timestamp);
        assertGt(shares, 0, "deposit must mint shares to the new depositor");
    }
}