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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./IL2FlashLoan.sol";

bool public constant IS_UPGRADEABLE = false;
uint256 public constant FLASH_LOAN_FEE_RATE = 2;
uint256 public constant MAX_FEE_RATE = 1000;
uint256 public constant ABSOLUTE_MAX_FLASH_LOAN = 10000 ether;
uint256 public immutable DEPLOYED_AT;
uint256 public immutable CREATION_BLOCK;

function flashLoan(uint256 amount, bytes calldata data) 
    external nonReentrant whenNotPaused {
    
    if (amount < 0.01 ether) revert FlashLoanAmountTooSmall();
    if (amount > ABSOLUTE_MAX_FLASH_LOAN) revert ExceedsAbsoluteLimit();
    if (amount > totalCommittedLiquidity) revert InsufficientLiquidity();
    
    uint256 fee = (amount * FLASH_LOAN_FEE_RATE) / 10000;
    flashLoanInProgress = true;
    
    _executeClosestMatchPulls(amount);
    
    // Send ETH to borrower
    (bool sendSuccess, ) = payable(msg.sender).call{value: amount}("");
    require(sendSuccess, "Transfer to borrower failed");
    
    // Execute borrower's strategy
    bool strategySuccess = IL2FlashLoan(msg.sender).executeFlashLoan(...);
    
    // Verify repayment
    bool repaymentSuccess = address(this).balance >= totalFlashLoanPulls + fee;
    
    if (strategySuccess && repaymentSuccess) {
        _distributeProfits(profit);
    } else {
        _returnAllPulledETH();
        revert FlashLoanFailed();
    }
}

function _distributeProfits(uint256 profit) internal {
    if (profit == 0 || totalFlashLoanPulls == 0) return;
    
    totalProfitPool += profit;
    
    // Distribute proportionally to AMOUNT LENT (lottery system)
    for (uint256 i = 0; i < liquidityProviders.length; i++) {
        address provider = liquidityProviders[i];
        uint256 lentAmount = flashLoanPulls[provider];
        
        if (lentAmount > 0) {
            uint256 userShare = (profit * lentAmount) / totalFlashLoanPulls;
            userProfitShares[provider] += userShare;
        }
    }
}

function withdrawCommitment(uint256 amount) 
    external nonReentrant noFlashLoan {
    
    uint256 currentCommitment = userCommitments[msg.sender];
    if (currentCommitment == 0) revert();
    
    if (amount == 0 || amount >= currentCommitment) {
        amount = currentCommitment;
    }
    
    userCommitments[msg.sender] -= amount;
    totalCommittedLiquidity -= amount;
}

function withdrawProfits() external nonReentrant {
    uint256 profit = userProfitShares[msg.sender];
    if (profit == 0) revert NoProfitsToWithdraw();
    
    userProfitShares[msg.sender] = 0;
    totalProfitWithdrawn += profit;
    
    (bool success, ) = payable(msg.sender).call{value: profit}("");
    require(success, "Transfer failed");
}