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

import "../Utility/owner.sol";

interface IBV3A {
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract BV3ASwap is Owner {
            IBV3A public bv3aToken;
            uint256 public totalBV3AReceived;


            mapping(address => uint256) public userContributions;
            mapping(uint256 => address[]) public userGroups;
            mapping(uint256 => uint256[]) public userGroupAmounts;


            uint256 public currentGroup = 1;
            uint256 private constant MAX_USERS_PER_GROUP = 20;
            uint256 private constant MIN_TRANSFER_AMOUNT = 10 * 10**18;


            // Function to set the BV3A token address, only callable by the contract owner
            function setBV3ATokenAddress(address _bv3aTokenAddress) external onlyOwner {
                bv3aToken = IBV3A(_bv3aTokenAddress);
            }

            function approveBV3A(uint256 _amount) external {
                require(bv3aToken.approve(address(this), _amount), "Approval failed");
            }

            function transferFromUser(uint256 _amount) external {
                require(_amount >= MIN_TRANSFER_AMOUNT, "Transfer amount is less than minimum required");
                require(bv3aToken.transferFrom(msg.sender, address(this), _amount), "Transfer failed");
                totalBV3AReceived += _amount;
                userContributions[msg.sender] += _amount;

                if (userGroups[currentGroup].length >= MAX_USERS_PER_GROUP) {
                    currentGroup++;
                }
                userGroups[currentGroup].push(msg.sender);
                userGroupAmounts[currentGroup].push(_amount);
            }


            // View function to check the total amount of BV3A tokens received by the contract
            function getTotal_BV3A_Received() external view returns (uint256) {
                return totalBV3AReceived;
            }

            // View function to check the amount of BV3A tokens contributed by a specific user
            function getUserContribution(address _user) external view returns (uint256) {
                return userContributions[_user];
            }

            function getADDRESSESUserGroupAmounts(uint256 groupNumber) external view returns (address[] memory) {
                return userGroups[groupNumber];
            }

            function getUserGroupAmounts(uint256 groupNumber) external view returns (uint256[] memory) {
                return userGroupAmounts[groupNumber];
            }

            function getUserGroupDoubledAmounts(uint256 groupNumber) external view returns (uint256[] memory) {
                uint256[] memory originalAmounts = userGroupAmounts[groupNumber];
                uint256[] memory doubledAmounts = new uint256[](originalAmounts.length);

                for (uint i = 0; i < originalAmounts.length; i++) {
                    doubledAmounts[i] = originalAmounts[i] * 2;
                }

                return doubledAmounts;
            }
}

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

contract Owner {
    address public _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

    modifier onlyOwner() {
        require(isOwner(), "You are not the owner");
        _;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "New owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }


    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }


    function getOwner() public view returns (address) {
        return _owner;
    }

}

{
  "compilationTarget": {
    "NEW_BV3/SWAPS/BV3A.sol": "BV3ASwap"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}