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

contract SlowClaimMalusEscrow {
    address payable private immutable provider;
    address payable private immutable payer;
    uint256 private immutable graceEnd;
    uint256 private immutable deadline;
    uint256 private immutable deposit;
    bool private claimed;

    event Claimed(address indexed provider, uint256 amount);
    event Withdrawn(address indexed payer, uint256 amount);

    constructor(address _provider, uint256 _graceEnd, uint256 _deadline) payable {
        require(_provider != address(0));
        require(_graceEnd > block.timestamp);
        require(_deadline > _graceEnd);
        require(msg.value > 0);
        provider = payable(_provider);
        payer = payable(msg.sender);
        graceEnd = _graceEnd;
        deadline = _deadline;
        deposit = msg.value;
    }

    function claim() external {
        require(msg.sender == provider);
        require(!claimed);
        require(block.timestamp >= graceEnd);
        uint256 amount;
        if (block.timestamp >= deadline) {
            amount = 0;
        } else {
            amount = deposit * (deadline - block.timestamp) / (deadline - graceEnd);
        }
        claimed = true;
        if (amount > 0) {
            (bool ok, ) = provider.call{value: amount}("");
            require(ok);
        }
        emit Claimed(provider, amount);
    }

    function withdrawAfterDeadline() external {
        require(msg.sender == payer);
        require(block.timestamp > deadline);
        uint256 amount = address(this).balance;
        require(amount != 0);
        (bool ok, ) = payer.call{value: amount}("");
        require(ok);
        emit Withdrawn(payer, amount);
    }
}