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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

contract WETH9Mock is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract SeatMock is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

    function mint(address to, uint256 id) external {
        _mint(to, id);
    }
}

/// A marked expected loss is released at once by startAuction (and restartAuction) through
/// markAuctionLoss(..., mayDecrease = true). Nothing vests that release, unlike settleAuction (F4),
/// so a lender who exits right after startAuction takes the other lenders' share of a loss that is
/// re-marked days later when the Dutch price decays below principal again.
contract AllowanceDropExitTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("honest lender");
    address internal carol = makeAddr("exiting lender");
    address internal keeper = makeAddr("keeper");
    PawnShop internal shop;
    LendingPool internal pool;
    SeatMock internal nft;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 10 ether);
        vm.deal(bob, 10 ether);
        vm.deal(carol, 10 ether);
        LaunchToken token = new LaunchToken();
        WETH9Mock weth = new WETH9Mock();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        SeatMock template = new SeatMock();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = SeatMock(shop.IDENTITY_COLLECTION());
        vm.prank(owner);
        shop.setNewLoansPaused(false);
    }

    function _floor(uint256 price) internal {
        vm.warp(vm.getBlockTimestamp() + 1);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("floor", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function test_lenderExitsAtInflatedPriceAfterStartAuctionReleasesAllowance() public {
        // Two equal lenders.
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
        vm.prank(carol);
        pool.depositETH{value: 5 ether}(carol);

        // Alice borrows 0.4 ETH against a 1 ETH floor for 30 days.
        _floor(1 ether);
        nft.mint(alice, 1);
        vm.startPrank(alice);
        nft.approve(address(shop), 1);
        uint256 id = shop.pawn(address(nft), 1, 0, 0, type(uint256).max);
        vm.stopPrank();

        // The floor halves; at the due date the expected loss 0.4 - 0.25 = 0.15 is booked (F5).
        _floor(0.5 ether);
        vm.warp(shop.getLoan(id).due);
        shop.markOverdue(id);
        assertEq(pool.auctionLoss(id), 0.15 ether);

        vm.warp(shop.getLoan(id).due + 3 days + 1);
        _floor(0.5 ether);
        uint256 carolFairBefore = pool.previewRedeem(pool.balanceOf(carol));
        uint256 bobFairBefore = pool.previewRedeem(pool.balanceOf(bob));

        // Anyone starts the auction: the opening price equals the fresh floor, so the allowance drops to 0
        // at once and totalAssets() jumps by 0.15 ETH with nothing vesting it.
        vm.prank(keeper);
        shop.startAuction(id);
        assertEq(pool.auctionLoss(id), 0);
        assertEq(pool.unvestedRelease(), 0);

        // Carol exits in the next block at the inflated price.
        vm.warp(vm.getBlockTimestamp() + 1);
        uint256 carolShares = pool.balanceOf(carol);
        vm.prank(carol);
        uint256 carolOut = pool.redeemETH(carolShares, carol, carol);
        emit log_named_uint("carol fair value before startAuction", carolFairBefore);
        emit log_named_uint("carol redeemed right after startAuction", carolOut);

        // The price decays to the 0.25 ETH terminal and the same 0.15 ETH loss is re-marked on Bob alone.
        vm.warp(vm.getBlockTimestamp() + 10 days);
        shop.markAuctionLoss(id);
        assertEq(pool.auctionLoss(id), 0.15 ether);
        vm.warp(vm.getBlockTimestamp() + 7 days);
        uint256 bobAfter = pool.previewRedeem(pool.balanceOf(bob));
        emit log_named_uint("bob fair value before startAuction", bobFairBefore);
        emit log_named_uint("bob value after the loss is re-marked", bobAfter);

        // A recognised gap must be shared before a lender exits (README); the release must vest (F4).
        assertLe(carolOut, carolFairBefore + 1, "exiting lender escaped its share of the recognised loss");
        assertGe(bobAfter + 1, bobFairBefore, "remaining lender bears the exiting lender's share of the loss");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

contract WETH9Mock is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract SeatMock is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

    function mint(address to, uint256 id) external {
        _mint(to, id);
    }
}

/// writeOffAuction books the whole principal as a realised loss while the collateral is still in its
/// auction and still sellable. Entry pricing then excludes the recovery entirely, so a buyer who first
/// deposits into the pool gets most of its own purchase price back through receiveRecovery.
contract WriteOffRecoveryCaptureTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("honest lender");
    address internal carol = makeAddr("buyer-depositor");
    PawnShop internal shop;
    LendingPool internal pool;
    SeatMock internal nft;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 10 ether);
        vm.deal(bob, 10 ether);
        vm.deal(carol, 10 ether);
        LaunchToken token = new LaunchToken();
        WETH9Mock weth = new WETH9Mock();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        SeatMock template = new SeatMock();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = SeatMock(shop.IDENTITY_COLLECTION());
        vm.prank(owner);
        shop.setNewLoansPaused(false);
    }

    function _floor(uint256 price) internal {
        vm.warp(vm.getBlockTimestamp() + 1);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("floor", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function test_buyerDepositsAfterWriteOffAndRecoversMostOfItsOwnPrice() public {
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
        _floor(1 ether);
        nft.mint(alice, 1);
        vm.startPrank(alice);
        nft.approve(address(shop), 1);
        uint256 id = shop.pawn(address(nft), 1, 0, 0, type(uint256).max);
        vm.stopPrank();

        vm.warp(shop.getLoan(id).due + 3 days + 1);
        _floor(1 ether);
        shop.startAuction(id);
        vm.warp(vm.getBlockTimestamp() + 40 days);
        uint256 bobBeforeWriteOff = pool.previewRedeem(pool.balanceOf(bob));
        shop.writeOffAuction(id); // principal 0.4 booked as loss; NFT still in auction at 0.5 ETH
        uint256 bobAfterWriteOff = pool.previewRedeem(pool.balanceOf(bob));
        emit log_named_uint("bob before write-off", bobBeforeWriteOff);
        emit log_named_uint("bob after write-off", bobAfterWriteOff);

        // Carol deposits at the written-down price (cap room: 10 - ~4.61), then buys the NFT at 0.5 ETH.
        vm.prank(carol);
        pool.depositETH{value: 5 ether}(carol);
        uint256 price = shop.auctionPrice(id);
        vm.prank(carol);
        shop.buyAuction{value: price}(id, carol);
        assertEq(nft.ownerOf(1), carol);
        assertEq(pool.cumulativeRecoveries(), 0.4 ether);

        vm.warp(vm.getBlockTimestamp() + 7 days); // recovery vests
        uint256 carolShares = pool.previewRedeem(pool.balanceOf(carol));
        uint256 bobFinal = pool.previewRedeem(pool.balanceOf(bob));
        emit log_named_uint("price carol paid", price);
        emit log_named_uint("carol share value after vesting", carolShares);
        emit log_named_uint("carol net cost of the NFT", price - (carolShares - 5 ether));
        emit log_named_uint("bob final", bobFinal);
        emit log_named_uint("bob recovery kept", bobFinal - bobAfterWriteOff);
        // Bob bore the full 0.4 ETH write-off and the NFT then sold for more than principal, so the
        // recovery should make him whole; instead most of it goes to the buyer's fresh deposit.
        assertGe(bobFinal + 1, bobBeforeWriteOff, "lender who bore the write-off is not made whole by the recovery");
    }
}