pragma solidity 0.8.13;

import { UD60x18 } from "@prb/math/UD60x18.sol";
import { IERC20 } from "@root/interfaces/IERC20.sol";

import { inv, add, sub, mul, exp, ln, wrap, unwrap, gte, mod, div } from "@prb/math/UD60x18.sol";

/*
    * @title Rolling Dutch Auction 
    * @author Samuel JJ Gosling 
    * @description A dutch auction derivative with composite logarithimic decay 
*/

contract RollingDutchAuction {

    /*  @dev Address mapping for an auction's redeemable balances  */
    mapping(address => mapping(bytes => bytes)) public _claims;

    /*  @dev Auction mapping translating to an indexed window      */
    mapping(bytes => mapping(uint256 => Window)) public _window;

    /*  @dev Auction mapping for associated parameters             */
    mapping(bytes => Auction) public _auctions;

    /*  @dev Auction mapping for the window index                  */
    mapping(bytes => uint256) public _windows;

    struct Auction {
        uint256 windowDuration;     /*  @dev Unix time window duration         */
        uint256 windowTimestamp;    /*  @dev Unix timestamp for window start   */
        uint256 startTimestamp;     /*  @dev Unix auction start timestamp      */ 
        uint256 endTimestamp;       /*  @dev Unix auction end timestamp        */
        uint256 duration;           /*  @dev Unix time auction duration        */
        uint256 proceeds;           /*  @dev Auction proceeds balance          */  
        uint256 reserves;           /*  @dev Auction reserves balance          */
        uint256 price;              /*  @dev Auction origin price              */
    }

    struct Window {
        bytes bidId;        /*  @dev Bid identifier                     */ 
        uint256 expiry;     /*  @dev Unix timestamp window exipration   */
        uint256 price;      /*  @dev Window price                       */
        uint256 volume;     /*  @dev Window volume                      */
        bool processed;     /*  @dev Window fuflfillment state          */
    }

    /*  
        * @dev Conditioner to ensure an auction is active  
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */  
    modifier activeAuction(bytes memory auctionId) {
        require(remainingWindowTime(auctionId) > 0 || remainingTime(auctionId) > 0);
        _;
    }

    /*  
        * @dev Conditioner to ensure an auction is inactive  
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */  
    modifier inactiveAuction(bytes memory auctionId) {
        require(remainingWindowTime(auctionId) == 0 && remainingTime(auctionId) == 0);
        _;
    }

    /*  
        * @dev Helper to view an auction's operator address  
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */  
    function operatorAddress(bytes memory auctionId) public pure returns (address opAddress) {
        (opAddress,,,,) = abi.decode(auctionId, (address, address, address, uint256, bytes));
    }

    /*  
        * @dev Helper to view an auction's purchase token address  
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Ancoded auction parameter identifier    
    */  
    function purchaseToken(bytes memory auctionId) public pure returns (address tokenAddress) {
        (,, tokenAddress,,) = abi.decode(auctionId, (address, address, address, uint256, bytes));
    }

    /*  
        * @dev Helper to view an auction's reserve token address  
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */  
    function reserveToken(bytes memory auctionId) public pure returns (address tokenAddress) {
        (, tokenAddress,,,) = abi.decode(auctionId, (address, address, address, uint256, bytes));
    }

    /*  
        * @dev Helper to decode claim hash balances
        * @param c͟l͟a͟i͟m͟H͟a͟s͟h͟ Encoded (uint256, uint256) values 
    */  
    function balancesOf(bytes memory claimHash) public pure returns (uint256, uint256) {
        uint256 refundBalance;
        uint256 claimBalance;

        if (keccak256(claimHash) != keccak256(bytes(""))) {
            (refundBalance, claimBalance) = abi.decode(claimHash, (uint256, uint256));
        }

        return (refundBalance, claimBalance);
    }

    /*  
        * @dev Auction deployment
        * @param o͟p͟e͟r͟a͟t͟o͟r͟A͟d͟r͟e͟s͟s͟ Auction management address
        * @param r͟e͟s͟e͟r͟v͟e͟T͟o͟k͟e͟n͟ Auctioning token address
        * @param p͟u͟r͟c͟h͟a͟s͟e͟T͟o͟k͟e͟n͟ Currency token address
        * @param r͟e͟s͟e͟r͟v͟e͟A͟m͟o͟u͟n͟t͟ Auctioning token amount
        * @param m͟i͟n͟i͟m͟u͟m͟P͟u͟r͟c͟h͟a͟s͟e͟A͟m͟o͟u͟n͟t͟ Minimum currency purchase amount 
        * @param s͟t͟a͟r͟t͟i͟n͟g͟O͟r͟i͟g͟i͟n͟P͟r͟i͟c͟e͟ Auction starting price 
        * @param s͟t͟a͟r͟t͟T͟i͟m͟e͟s͟t͟a͟m͟p͟ Unix timestamp auction initiation
        * @param e͟n͟d͟T͟i͟m͟e͟s͟t͟a͟m͟p͟ Unix timestamp auction expiration
        * @param w͟i͟n͟d͟o͟w͟D͟u͟r͟a͟t͟i͟o͟n͟ Uinx time window duration
    */  
    function createAuction(
        address operatorAddress,
        address reserveToken,
        address purchaseToken,
        uint256 reserveAmount,
        uint256 minimumPurchaseAmount,
        uint256 startingOriginPrice,
        uint256 startTimestamp,
        uint256 endTimestamp,
        uint256 windowDuration
    ) public returns (bytes memory) {
        bytes memory auctionId = abi.encode(
            operatorAddress,
            reserveToken,
            purchaseToken,
            minimumPurchaseAmount,
            abi.encodePacked(reserveAmount, startingPrice, startTimestamp, endTimestamp, windowDuration)
        );

        Auction storage state = _auctions[auctionId];

        require(state.price == 0, "AUCTION EXISTS");

        IERC20(reserveToken).transferFrom(msg.sender, address(this), reserveAmount);

        state.duration = endTimestamp - startTimestamp;
        state.windowDuration = windowDuration;
        state.windowTimestamp = startTimestamp;
        state.startTimestamp = startTimestamp;
        state.endTimestamp = endTimestamp;
        state.price = startingOriginPrice;
        state.reserves = reserveAmount;

        emit NewAuction(auctionId, reserveToken, reserveAmount, startingPrice, endTimestamp);

        return auctionId;
    }

    /*  
        * @dev Helper to view an auction's minimum purchase amount   
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */  
    function minimumPurchase(bytes memory auctionId) public pure returns (uint256 minimumAmount) {
        (,,, minimumAmount,) = abi.decode(auctionId, (address, address, address, uint256, bytes));
    }

    /*  
        * @dev Helper to view an auction's maximum order reserve amount  
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */   
    function maximumPurchase(bytes memory auctionId) public view returns (uint256) {
        return unwrap(inv(scalarPrice(auctionId)));
    }

    /*  
        * @dev Helper to view an auction's active scalar price formatted to uint256  
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */  
    function scalarPriceUint(bytes memory auctionId) public view returns (uint256) {
        return unwrap(scalarPrice(auctionId));
    }

    /*  
        * @dev Active price decay following time delta (x) between the current 
        * timestamp and the window's start timestamp or if the window is expired; time 
        * delta between the window's expiration. Which is the applied as the exponent 
        * of Euler's number and subject to the natural logarithim. Finally applied as  
        * as a product to the origin price (y) and substracted from itself
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */      
    function scalarPrice(bytes memory auctionId) public view returns (UD60x18) {
        Auction storage state = _auctions[auctionId];
        Window storage w = _window[auctionId][_windows[auctionId]];

        bool isInitialised = w.expiry != 0;
        bool isExpired = w.expiry < block.timestamp && isInitialised;

        uint256 timestamp = isExpired ? w.expiry : state.windowTimestamp;

        UD60x18 t = wrap(block.timestamp - timestamp);
        UD60x18 t_r = wrap(state.endTimestamp - timestamp);

        UD60x18 x = div(add(t, mod(t, sub(t_r, t))), t_r);
        UD60x18 y = !isInitialised ? wrap(state.price) : wrap(w.price);

        return sub(y, mul(ln(exp(x)), y));
    }

    /*  
        * @dev Bid submission 
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
        * @param p͟r͟i͟c͟e͟ Bid order price  
        * @param v͟o͟l͟u͟m͟e͟ Bid order volume
    */     
    function commitBid(bytes memory auctionId, uint256 price, uint256 volume) 
        activeAuction(auctionId) 
    public returns (bytes memory) {
        Window storage w = _window[auctionId][_windows[auctionId]];

        require(minimumPurchase(auctionId) <= volume, "INSUFFICIENT VOLUME");

        bool hasExpired;

        if (w.expiry != 0) {
            if (remainingWindowTime(auctionId) > 0) {
                if (w.price < price) {
                    require(w.volume <= volume, "INSUFFICIENT WINDOW VOLUME");
                } else {
                    require(w.price < price, "INVALID WINDOW PRICE");
                }
            } else {
                hasExpired = true;
            }
        }

        if (w.price == 0 || hasExpired) {
            require(gte(wrap(price), scalarPrice(auctionId)), "INVALID CURVE PRICE");
        }

        IERC20(purchaseToken(auctionId)).transferFrom(msg.sender, address(this), volume);

        require(_auctions[auctionId].reserves >= (volume / price), "INSUFFICIENT RESERVES");
        require(maximumPurchase(auctionId) >= (volume / price), "INVALID VOLUME");

        bytes memory bidId = abi.encode(auctionId, msg.sender, price, volume);

        (uint256 refund, uint256 claim) = balancesOf(_claims[msg.sender][auctionId]);

        _claims[msg.sender][auctionId] = abi.encode(refund + volume, claim);

        if (hasExpired) {
            w = _window[auctionId][windowExpiration(auctionId)];
        } 

        _auctions[auctionId].windowTimestamp = block.timestamp;

        w.expiry = block.timestamp + _auctions[auctionId].windowDuration;
        w.volume = volume;
        w.price = price;
        w.bidId = bidId;

        emit Offer(auctionId, msg.sender, w.bidId, w.expiry);

        return bidId;
    }

    /*  
        * @dev Expire and fulfill an auction's active window  
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */     
    function windowExpiration(bytes memory auctionId) internal returns (uint256) {
        uint256 windowIndex = _windows[auctionId];
        uint256 auctionElapsedTime = elapsedTime(auctionId, block.timestamp);
        uint256 auctionRemainingTime = _auctions[auctionId].duration - auctionElapsedTime;

        bytes memory winningBidId = _window[auctionId][windowIndex].bidId;

        _auctions[auctionId].endTimestamp = block.timestamp + auctionRemainingTime;
        _auctions[auctionId].price = _window[auctionId][windowIndex].price;

        _windows[auctionId] = windowIndex + 1;

        fulfillWindow(auctionId, windowIndex);

        emit Expiration(auctionId, winningBidId, windowIndex);

        return windowIndex + 1;
    }

    /*  
        * @dev Fulfill a window index even if the auction is inactive 
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */  
    function fulfillWindow(bytes memory auctionId, uint256 windowId) public {
        Window storage w = _window[auctionId][windowId];

        require(w.expiry < block.timestamp, "WINDOW UNEXPIRED");
        require(!w.processed, "WINDOW ALREADY FUFILLED");

        (, address bidder, uint256 price, uint256 volume) = abi.decode(w.bidId, (bytes, address, uint256, uint256));
        (uint256 refund, uint256 claim) = balancesOf(_claims[bidder][auctionId]);

        delete _claims[bidder][auctionId];

        w.processed = true;

        _auctions[auctionId].reserves -= volume / price;
        _auctions[auctionId].proceeds += volume;

        _claims[bidder][auctionId] = abi.encode(refund - volume, claim + (volume / price));

        emit Fufillment(auctionId, w.bidId, windowId);
    }

    /*  
        * @dev Helper to view an auction's remaining duration
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */  
    function remainingTime(bytes memory auctionId) public view returns (uint256) {
        uint256 endTimestamp = _auctions[auctionId].endTimestamp;

        if (endTimestamp > block.timestamp) {
            return endTimestamp - block.timestamp;
        } else {
            return 0;
        }
    }

    /*  
        * @dev Helper to view an auction's active remaining window duration
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */  
    function remainingWindowTime(bytes memory auctionId) public view returns (uint256) {
        uint256 expiryTimestamp = _window[auctionId][_windows[auctionId]].expiry;

        if (expiryTimestamp == 0 || block.timestamp > expiryTimestamp) {
            return 0;
        } else {
            return expiryTimestamp - block.timestamp;
        }
    }

    /*  
        * @dev Helper to view an auction's progress in unix time
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */     
    function elapsedTime(bytes memory auctionId, uint256 timestamp) public view returns (uint256) {
        uint256 windowIndex = _windows[auctionId] + 1;
        uint256 windowElapsedTime = _auctions[auctionId].windowDuration * windowIndex;

        return timestamp - _auctions[auctionId].startTimestamp - windowElapsedTime;
    }

    /*  
        * @dev Auction management redemption 
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */     
    function withdraw(bytes memory auctionId) 
        inactiveAuction(auctionId) 
    public {
        uint256 proceeds = _auctions[auctionId].proceeds;
        uint256 reserves = _auctions[auctionId].reserves;

        delete _auctions[auctionId].proceeds;
        delete _auctions[auctionId].reserves;

        if (proceeds > 0) {
            IERC20(purchaseToken(auctionId)).transfer(operatorAddress(auctionId), proceeds);
        }
        if (reserves > 0) {
            IERC20(reserveToken(auctionId)).transfer(operatorAddress(auctionId), reserves);
        }

        emit Withdraw(auctionId);
    }

    /*  
        * @dev Auction order and refund redemption 
        * @param a͟u͟c͟t͟i͟o͟n͟I͟d͟ Encoded auction parameter identifier    
    */  
    function redeem(address bidder, bytes memory auctionId)
        inactiveAuction(auctionId) 
    public {
        bytes memory claimHash = _claims[bidder][auctionId];

        (uint256 refund, uint256 claim) = balancesOf(claimHash);

        delete _claims[bidder][auctionId];

        if (refund > 0) {
            IERC20(purchaseToken(auctionId)).transfer(bidder, refund);
        }
        if (claim > 0) {
            IERC20(reserveToken(auctionId)).transfer(bidder, claim);
        }

        emit Claim(auctionId, claimHash);
    }

    event NewAuction(
        bytes indexed auctionId, address reserveToken, uint256 reserves, uint256 price, uint256 endTimestamp
    );

    event Offer(bytes indexed auctionId, address indexed owner, bytes indexed bidId, uint256 expiry);

    event Fufillment(bytes indexed auctionId, bytes indexed bidId, uint256 windowId);

    event Expiration(bytes indexed auctionId, bytes indexed bidId, uint256 windowId);

    event Claim(bytes indexed auctionId, bytes indexed bidId);

    event Withdraw(bytes indexed auctionId);
}