//SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
 
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; 
import "@openzeppelin/contracts/access/AccessControl.sol";
contract ResellablePaymentSplitter is AccessControl,ReentrancyGuard  {
     bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    address[] public payees;
    mapping(address => uint256) public shares;
    address[] admins;

    constructor(address[] memory _admins,address[] memory _payees, uint256[] memory _shares) {
        require(_payees.length == _shares.length, "Payees and shares lengths must match");
        require(_payees.length > 0, "There must be at least one payee");
        admins = _admins;  
        uint256 totalShares = 0;
        for (uint256 i = 0; i < _payees.length; i++) {
            require(_payees[i] != address(0), "Payee address cannot be zero");
            require(_shares[i] > 0, "Shares must be greater than zero");

            totalShares += _shares[i];
            payees.push(_payees[i]);
            shares[_payees[i]] = _shares[i];
        }

        require(totalShares == 100, "Total shares must equal 100%");
        
        for (uint256 i = 0; i < _admins.length; ++i) {
            
            _grantRole(ADMIN_ROLE, _admins[i]);
            _grantRole(DEFAULT_ADMIN_ROLE, _admins[i]);
        }
    }

     modifier onlyAdmin() {
         require(hasRole(ADMIN_ROLE, msg.sender), "DOES_NOT_HAVE_ADMIN_ROLE");
        _;
    }

    function updatePayeeShare(address _payee, uint256 _newShare) public onlyAdmin {
        require(_payee != address(0), "Payee address cannot be zero");
        require(_newShare > 0, "Shares must be greater than zero");

        uint256 currentShare = shares[_payee];
        require(currentShare != 0, "Payee not found");

        shares[_payee] = _newShare;
    }

    receive() external payable {
        uint256 totalReceived = msg.value;
        for (uint256 i = 0; i < payees.length; i++) {
            address payee = payees[i];
            uint256 share = (totalReceived * shares[payee]) / 100;
            (bool success, ) = payable(payee).call{value: share}("");
            require(success, "Transfer failed.");  
        }
    }

    function withdrawExcess() external onlyAdmin {
        payable(msg.sender).transfer(address(this).balance);
    }
}

/*
contract ResellablePaymentSplitter is TokenPaymentSplitter {
    
    constructor (
        address[] memory payees,
        uint256[] memory shares_
    ) payable
    TokenPaymentSplitter(payees, shares_)
    {}
 
 
}
*/