pragma solidity 0.5.11;

contract gamechanger {
    address public ownerWallet;
    struct Variables {
        uint currUserID          ;
        uint pool1currUserID     ;
        uint pool2currUserID     ;
        uint pool3currUserID     ;
        uint pool4currUserID     ;
        uint pool5currUserID     ;
        uint pool6currUserID     ;
        uint pool7currUserID     ;
    }
    struct Variables2 {
        uint pool1activeUserID   ;
        uint pool2activeUserID   ;
        uint pool3activeUserID   ;
        uint pool4activeUserID   ;
        uint pool5activeUserID   ;
        uint pool6activeUserID   ;
        uint pool7activeUserID   ;
    }
    Variables public vars;
    Variables2 public vars2;

    struct UserStruct {
        bool isExist;
        uint id;
        uint referrerID;
        uint referredUsers;
        
    }
    
    struct PoolUserStruct {
        bool isExist;
        uint id;
        uint payment_received; 
        uint autojoinCount;
    }
    
    mapping (address => UserStruct) public users;
    mapping (uint => address) public userList;
    
    mapping (address => PoolUserStruct) public pool1users;
    mapping (uint => address) public pool1userList;
    
    mapping (address => PoolUserStruct) public pool2users;
    mapping (uint => address) public pool2userList;
    
    mapping (address => PoolUserStruct) public pool3users;
    mapping (uint => address) public pool3userList;
    
    mapping (address => PoolUserStruct) public pool4users;
    mapping (uint => address) public pool4userList;
    
    mapping (address => PoolUserStruct) public pool5users;
    mapping (uint => address) public pool5userList;
    
    mapping (address => PoolUserStruct) public pool6users;
    mapping (uint => address) public pool6userList;
    
    mapping (address => PoolUserStruct) public pool7users;
    mapping (uint => address) public pool7userList;
    
     
    mapping(uint => uint) public LEVEL_PRICE;
    
    uint public unlimited_level_price   = 0;
    
    uint REGESTRATION_FESS      =   0.10    ether;
    
    uint pool1_price            =   0.10    ether;
    uint pool2_price            =   0.20    ether;
    uint pool3_price            =   0.50    ether;
    uint pool4_price            =   1.00    ether;
    uint pool5_price            =   2.00    ether;
    uint pool6_price            =   5.00    ether;
    uint pool7_price            =   10.00    ether;

   
    event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
    event getMoneyForLevelEvent(address indexed _user, address indexed _referral,uint _poolNumber, uint _level, uint _time);
    event regPoolEntry(address indexed _user,uint _level,   uint _time);
    event getPoolPayment(address indexed _user,address indexed _receiver, uint _level, uint _time);
    event getMoneyForPoolEvent(address indexed _user, address indexed _referral,uint _level, uint _time);
    
    UserStruct[] public requests;
    uint public totalEarned = 0;
     
    constructor() public {
        ownerWallet = msg.sender;

        LEVEL_PRICE[1] = 0.01 ether;   
        LEVEL_PRICE[2] = 0.005 ether; 

        UserStruct memory userStruct;
        vars.currUserID++;

        userStruct = UserStruct({
            isExist: true,
            id: vars.currUserID,
            referrerID: 0,
            referredUsers:0
        });
        
        users[ownerWallet] = userStruct;
        userList[vars.currUserID] = ownerWallet;
       
       
        PoolUserStruct memory pooluserStruct;
        
        vars.pool1currUserID++;
        pooluserStruct = PoolUserStruct({
            isExist:true,
            id:vars.pool1currUserID,
            payment_received:0,
            autojoinCount:0
        });
        vars2.pool1activeUserID=vars.pool1currUserID;
        pool1users[msg.sender] = pooluserStruct;
        pool1userList[vars.pool1currUserID]=msg.sender;

        vars.pool2currUserID++;
        pooluserStruct = PoolUserStruct({
            isExist:true,
            id:vars.pool2currUserID,
            payment_received:0,
            autojoinCount:0
        });
        vars2.pool2activeUserID=vars.pool2currUserID;
        pool2users[msg.sender] = pooluserStruct;
        pool2userList[vars.pool2currUserID]=msg.sender;
       
        vars.pool3currUserID++;
        pooluserStruct = PoolUserStruct({
            isExist:true,
            id:vars.pool3currUserID,
            payment_received:0,
            autojoinCount:0
        });
        vars2.pool3activeUserID=vars.pool3currUserID;
        pool3users[msg.sender] = pooluserStruct;
        pool3userList[vars.pool3currUserID]=msg.sender;
       
        vars.pool4currUserID++;
        pooluserStruct = PoolUserStruct({
            isExist:true,
            id:vars.pool4currUserID,
            payment_received:0,
            autojoinCount:0
        });
        vars2.pool4activeUserID=vars.pool4currUserID;
        pool4users[msg.sender] = pooluserStruct;
        pool4userList[vars.pool4currUserID]=msg.sender;

        vars.pool5currUserID++;
        pooluserStruct = PoolUserStruct({
            isExist:true,
            id:vars.pool5currUserID,
            payment_received:0,
            autojoinCount:0
        });
        vars2.pool5activeUserID=vars.pool5currUserID;
        pool5users[msg.sender] = pooluserStruct;
        pool5userList[vars.pool5currUserID]=msg.sender;

        vars.pool6currUserID++;
        pooluserStruct = PoolUserStruct({
            isExist:true,
            id:vars.pool6currUserID,
            payment_received:0,
            autojoinCount:0
        });
        vars2.pool6activeUserID=vars.pool6currUserID;
        pool6users[msg.sender] = pooluserStruct;
        pool6userList[vars.pool6currUserID]=msg.sender;
       
        vars.pool7currUserID++;
        pooluserStruct = PoolUserStruct({
            isExist:true,
            id:vars.pool7currUserID,
            payment_received:0,
            autojoinCount:0
        });
        vars2.pool7activeUserID=vars.pool7currUserID;
        pool7users[msg.sender] = pooluserStruct;
        pool7userList[vars.pool7currUserID]=msg.sender;
       
       
       
    }
     
    function regUser(uint _referrerID) public payable {
       
        require(!users[msg.sender].isExist, "User Exists");
        require(_referrerID > 0 && _referrerID <= vars.currUserID, 'Incorrect referral ID');
        require(msg.value == REGESTRATION_FESS, 'Incorrect Value');
       
        UserStruct memory userStruct;
        vars.currUserID++;

        userStruct = UserStruct({
            isExist: true,
            id: vars.currUserID,
            referrerID: _referrerID,
            referredUsers:0
        });
   
        users[msg.sender] = userStruct;
        userList[vars.currUserID]=msg.sender;
       
        users[userList[users[msg.sender].referrerID]].referredUsers=users[userList[users[msg.sender].referrerID]].referredUsers+1;
        emit regLevelEvent(msg.sender, userList[_referrerID], now);

        //Register pool 1 and pay the rest to active user
        buyPool1();
        
    }
    function buyPool1() internal {
        bool isinpool = isInPool(1,msg.sender);
        require(!isinpool, "Already in AutoPool");

        PoolUserStruct memory userStruct;
        address poolCurrentActiveuser=getPoolCurrentActiveUser(1);
        increasePoolCurrentUserID(1);
        
        userStruct = PoolUserStruct({
            isExist:true,
            id:getPoolCurrentUserID(1),
            payment_received:0,
            autojoinCount:0
        });

        assignPoolUser(1,msg.sender,userStruct.id,userStruct);
        
        uint pool_price = getPoolPrice(1);
        
        //direct fee for referer (10%)
        uint fee_direct = (pool_price * 10) / 100;
        //level 2 fee for referer (5%)
        uint fee_level2 = (pool_price * 5) / 100;
        address referer;
        address referer_l2 = address(0);
        uint poolshare = pool_price - fee_direct;
         
        referer = userList[users[msg.sender].referrerID];
        
        if (users[referer].referrerID >= 1){
            referer_l2 = userList[users[referer].referrerID];
            poolshare -= fee_level2;
        }
        
        if (address(uint160(referer)).send(fee_direct)){
            emit getMoneyForLevelEvent(referer, msg.sender,1, 1, now);
            if (referer_l2 != address(0)){
                
                if (!address(uint160(referer_l2)).send(fee_level2))
                    revert();
                else
                    emit getMoneyForLevelEvent(referer_l2, msg.sender,1, 2, now);
            }
            
        }
        else 
            revert();
            
        if (address(uint160(poolCurrentActiveuser)).send(poolshare)) {
            totalEarned += poolshare;
            increasePoolPaymentReceive(1,poolCurrentActiveuser);
            uint currentAutoJoinCount = getPoolAutoRejoinCount(1,poolCurrentActiveuser);
            uint PaymentReceived = getPoolPaymentReceive(1,poolCurrentActiveuser);
            
            emit getMoneyForPoolEvent(referer, msg.sender,1, now);
            emit getPoolPayment(msg.sender,poolCurrentActiveuser, 1, now);
            emit regPoolEntry(msg.sender, 1, now);
            
            if ((PaymentReceived>=3 * (currentAutoJoinCount+1))&&(currentAutoJoinCount<10))
            {
                //re-join automatically
               
                increasePoolCurrentUserID(1);
                
                uint poolCurrentUserID = getPoolCurrentUserID(1);
                uint poolActiveID = getPoolActiveUserID(1);
                
                userStruct = PoolUserStruct({
                    isExist:true,
                    id:poolActiveID,
                    payment_received:PaymentReceived,
                    autojoinCount:currentAutoJoinCount+1
                });
                
                assignPoolUser(1,poolCurrentActiveuser,poolCurrentUserID,userStruct);
                
                //
                increasePoolActiveUserID(1);
                emit regPoolEntry(poolCurrentActiveuser, 1, now);
                
            }

        }
        else
            revert();
    }
    function buyPool(uint poolNumber) public payable{
        require(users[msg.sender].isExist, "User Not Registered");
        
        bool check = isInPool(poolNumber,msg.sender);
        require(!check, "Already in AutoPool");
        
        require(poolNumber>=2,"Pool number <2");
        require(poolNumber<=12,"Pool number >12");
        
        check = checkPrice(poolNumber,msg.value);
        require(check,"Price of Pool is Wrong");
        
        PoolUserStruct memory userStruct;
        address poolCurrentActiveuser=getPoolCurrentActiveUser(poolNumber);
        increasePoolCurrentUserID(poolNumber);
        
        userStruct = PoolUserStruct({
            isExist:true,
            id:getPoolCurrentUserID(poolNumber),
            payment_received:0,
            autojoinCount:0
        });

        assignPoolUser(poolNumber,msg.sender,userStruct.id,userStruct);
        
        uint pool_price = getPoolPrice(poolNumber);
        
        //direct fee for referer (10%)
        uint fee_direct = (pool_price * 10) / 100;
        //level 2 fee for referer (5%)
        uint fee_level2 = (pool_price * 5) / 100;
        address referer;
        address referer_l2 = address(0);
        uint poolshare = pool_price - fee_direct;
         
        referer = userList[users[msg.sender].referrerID];
        
        if (users[referer].referrerID >= 1){
            referer_l2 = userList[users[referer].referrerID];
            poolshare -= fee_level2;
        }
        
        if (address(uint160(referer)).send(fee_direct)){
            emit getMoneyForLevelEvent(referer, msg.sender,poolNumber, 1, now);
            if (referer_l2 != address(0)){
                
                if (!address(uint160(referer_l2)).send(fee_level2))
                    revert();
                else
                    emit getMoneyForLevelEvent(referer_l2, msg.sender,poolNumber, 2, now);
            }
            
        }
        else 
            revert();
            
        if (address(uint160(poolCurrentActiveuser)).send(poolshare)) {
            totalEarned += poolshare;
            increasePoolPaymentReceive(poolNumber,poolCurrentActiveuser);
            uint currentAutoJoinCount = getPoolAutoRejoinCount(poolNumber,poolCurrentActiveuser);
            uint PaymentReceived = getPoolPaymentReceive(poolNumber,poolCurrentActiveuser);

            emit getMoneyForPoolEvent(referer, msg.sender,poolNumber, now);
            emit getPoolPayment(msg.sender,poolCurrentActiveuser, poolNumber, now);
            emit regPoolEntry(msg.sender, poolNumber, now);
            
            if ((PaymentReceived>=3 * (currentAutoJoinCount+1))&&(currentAutoJoinCount<=10))
            {
                //re-join automatically
               
                increasePoolCurrentUserID(poolNumber);
                
                uint poolCurrentUserID = getPoolCurrentUserID(poolNumber);
                uint poolActiveID = getPoolActiveUserID(poolNumber);
                
                userStruct = PoolUserStruct({
                    isExist:true,
                    id:poolActiveID,
                    payment_received:PaymentReceived,
                    autojoinCount:currentAutoJoinCount+1
                });
                
                assignPoolUser(poolNumber,poolCurrentActiveuser,poolCurrentUserID,userStruct);
                
                //
                increasePoolActiveUserID(poolNumber);
                emit regPoolEntry(poolCurrentActiveuser, poolNumber, now);
                
            }

        }
        else
            revert();
        
    }
    
    function isInPool(uint _poolNumber,address _PoolMember) internal view returns (bool){
        if (_poolNumber == 1)
            return pool1users[_PoolMember].isExist;
        else if (_poolNumber == 2)
            return pool2users[_PoolMember].isExist;
        else if (_poolNumber == 3)
            return pool3users[_PoolMember].isExist;
        else if (_poolNumber == 4)
            return pool4users[_PoolMember].isExist;
        else if (_poolNumber == 5)
            return pool5users[_PoolMember].isExist;
        else if (_poolNumber == 6)
            return pool6users[_PoolMember].isExist;
        else if (_poolNumber == 7)
            return pool7users[_PoolMember].isExist;
        
        
        return true;
    }
    
    function checkPrice(uint _poolNumber,uint256 Amount) internal view returns (bool){
        bool ret = false;
        
        if ((_poolNumber == 1)&&(Amount ==pool1_price))
            ret = true;
        else if ((_poolNumber == 2)&&(Amount ==pool2_price))
            ret = true;
        else if ((_poolNumber == 3)&&(Amount ==pool3_price))
            ret = true;
        else if ((_poolNumber == 4)&&(Amount ==pool4_price))
            ret = true;
        else if ((_poolNumber == 5)&&(Amount ==pool5_price))
            ret = true;
        else if ((_poolNumber == 6)&&(Amount ==pool6_price))
            ret = true;
        else if ((_poolNumber == 7)&&(Amount ==pool7_price))
            ret = true;
        
            
        return ret;
    }
    
    function getPoolCurrentActiveUser(uint _poolNumber) internal view returns (address){
        if (_poolNumber == 1)
            return pool1userList[vars2.pool1activeUserID];
        else if (_poolNumber == 2)
            return pool2userList[vars2.pool2activeUserID];
        else if (_poolNumber == 3)
            return pool3userList[vars2.pool3activeUserID];
        else if (_poolNumber == 4)
            return pool4userList[vars2.pool4activeUserID];
        else if (_poolNumber == 5)
            return pool5userList[vars2.pool5activeUserID];
        else if (_poolNumber == 6)
            return pool6userList[vars2.pool6activeUserID];
        else if (_poolNumber == 7)
            return pool7userList[vars2.pool7activeUserID];
        
        
        return address(0);
    }
    
    function increasePoolCurrentUserID(uint _poolNumber) internal {
       if (_poolNumber == 1)
            vars.pool1currUserID++;
        else if (_poolNumber == 2)
            vars.pool2currUserID++;
        else if (_poolNumber == 3)
            vars.pool3currUserID++;
        else if (_poolNumber == 4)
            vars.pool4currUserID++;
        else if (_poolNumber == 5)
            vars.pool5currUserID++;
        else if (_poolNumber == 6)
            vars.pool6currUserID++;
        else if (_poolNumber == 7)
            vars.pool7currUserID++;
        
    }
    
    function getPoolCurrentUserID(uint _poolNumber) internal view returns (uint){
        if (_poolNumber == 1)
            return vars.pool1currUserID;
        else if (_poolNumber == 2)
            return vars.pool2currUserID;
        else if (_poolNumber == 3)
            return vars.pool3currUserID;
        else if (_poolNumber == 4)
            return vars.pool4currUserID;
        else if (_poolNumber == 5)
            return vars.pool5currUserID;
        else if (_poolNumber == 6)
            return vars.pool6currUserID;
        else if (_poolNumber == 7)
            return vars.pool7currUserID;
        
        
        return 0;
    }
    
    function assignPoolUser(uint _poolNumber,address newPoolMember,uint poolCurrentUserID,PoolUserStruct memory userStruct) internal {
        if (_poolNumber == 1){
            pool1users[newPoolMember] = userStruct;
            pool1userList[poolCurrentUserID]=newPoolMember;
        }
        else if (_poolNumber == 2){
            pool2users[newPoolMember] = userStruct;
            pool2userList[poolCurrentUserID]=newPoolMember;
        }
        else if (_poolNumber == 3){
            pool3users[newPoolMember] = userStruct;
            pool3userList[poolCurrentUserID]=newPoolMember;
        }
        else if (_poolNumber == 4){
            pool4users[newPoolMember] = userStruct;
            pool4userList[poolCurrentUserID]=newPoolMember;
        }
        else if (_poolNumber == 5){
            pool5users[newPoolMember] = userStruct;
            pool5userList[poolCurrentUserID]=newPoolMember;
        }
        else if (_poolNumber == 6){
            pool6users[newPoolMember] = userStruct;
            pool6userList[poolCurrentUserID]=newPoolMember;
        }
        else if (_poolNumber == 7){
            pool7users[newPoolMember] = userStruct;
            pool7userList[poolCurrentUserID]=newPoolMember;
        }
        
    }
    
    function getPoolPrice(uint _poolNumber) internal view returns (uint){
        if (_poolNumber == 1)
            return pool1_price;
        else if (_poolNumber == 2)
            return pool2_price;
        else if (_poolNumber == 3)
            return pool3_price;
        else if (_poolNumber == 4)
            return pool4_price;
        else if (_poolNumber == 5)
            return pool5_price;
        else if (_poolNumber == 6)
            return pool6_price;
        else if (_poolNumber == 7)
            return pool7_price;
        
        
        return 0;
    }
    
    function increasePoolPaymentReceive(uint _poolNumber, address CurrentUser) internal {
        if (_poolNumber == 1)
            pool1users[CurrentUser].payment_received+=1;
        else if (_poolNumber == 2)
            pool2users[CurrentUser].payment_received+=1;
        else if (_poolNumber == 3)
            pool3users[CurrentUser].payment_received+=1;
        else if (_poolNumber == 4)
            pool4users[CurrentUser].payment_received+=1;
        else if (_poolNumber == 5)
            pool5users[CurrentUser].payment_received+=1;
        else if (_poolNumber == 6)
            pool6users[CurrentUser].payment_received+=1;
        else if (_poolNumber == 7)
            pool7users[CurrentUser].payment_received+=1;
        
    }
    
    function getPoolPaymentReceive(uint _poolNumber, address CurrentUser) internal view returns(uint){
        if (_poolNumber == 1)
            return pool1users[CurrentUser].payment_received;
        else if (_poolNumber == 2)
            return pool2users[CurrentUser].payment_received;
        else if (_poolNumber == 3)
            return pool3users[CurrentUser].payment_received;
        else if (_poolNumber == 4)
            return pool4users[CurrentUser].payment_received;
        else if (_poolNumber == 5)
            return pool5users[CurrentUser].payment_received;
        else if (_poolNumber == 6)
            return pool6users[CurrentUser].payment_received;
        else if (_poolNumber == 7)
            return pool7users[CurrentUser].payment_received;
        
    }
    
    function getPoolAutoRejoinCount(uint _poolNumber, address CurrentUser) internal view returns(uint){
        if (_poolNumber == 1)
            return pool1users[CurrentUser].autojoinCount;
        else if (_poolNumber == 2)
            return pool2users[CurrentUser].autojoinCount;
        else if (_poolNumber == 3)
            return pool3users[CurrentUser].autojoinCount;
        else if (_poolNumber == 4)
            return pool4users[CurrentUser].autojoinCount;
        else if (_poolNumber == 5)
            return pool5users[CurrentUser].autojoinCount;
        else if (_poolNumber == 6)
            return pool6users[CurrentUser].autojoinCount;
        else if (_poolNumber == 7)
            return pool7users[CurrentUser].autojoinCount;
        
    }
    function increasePoolActiveUserID(uint _poolNumber) internal {
        if (_poolNumber == 1)
            vars2.pool1activeUserID+=1;
        else if (_poolNumber == 2)
            vars2.pool2activeUserID+=1;
        else if (_poolNumber == 3)
            vars2.pool3activeUserID+=1;
        else if (_poolNumber == 4)
            vars2.pool4activeUserID+=1;
        else if (_poolNumber == 5)
            vars2.pool5activeUserID+=1;
        else if (_poolNumber == 6)
            vars2.pool6activeUserID+=1;
        else if (_poolNumber == 7)
            vars2.pool7activeUserID+=1;
        
    }
    
    function getPoolActiveUserID(uint _poolNumber) internal view returns (uint){
        if (_poolNumber == 1)
            return vars2.pool1activeUserID;
        else if (_poolNumber == 2)
            return vars2.pool2activeUserID;
        else if (_poolNumber == 3)
            return vars2.pool3activeUserID;
        else if (_poolNumber == 4)
            return vars2.pool4activeUserID;
        else if (_poolNumber == 5)
            return vars2.pool5activeUserID;
        else if (_poolNumber == 6)
            return vars2.pool6activeUserID;
        else if (_poolNumber == 7)
            return vars2.pool7activeUserID;
 
        return 0;
    }
    
    function getEthBalance() public view returns(uint) {
    return address(this).balance;
    }
    
    function sendBalance() private
    {
         if (!address(uint160(ownerWallet)).send(getEthBalance()))
         {
             
         }
    }
   
   
}

{
  "compilationTarget": {
    "browser/game changer.sol": "gamechanger"
  },
  "evmVersion": "petersburg",
  "libraries": {},
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}