pragma solidity 0.4.25;

/**
 * @title ERC20 interface
 * @dev see https://eips.ethereum.org/EIPS/eip-20
 */
contract IERC20 {
    function transfer(address to, uint256 value) public returns (bool);

    function approve(address spender, uint256 value) public returns (bool);

    function transferFrom(address from, address to, uint256 value) public returns (bool);

    function balanceOf(address who) public view returns (uint256);

    function allowance(address owner, address spender) public view returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error.
 */
library SafeMath {
  /**
   * @dev Multiplies two unsigned integers, reverts on overflow.
   */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b);

    return c;
  }

  /**
   * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
   */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // Solidity only automatically asserts when dividing by 0
    require(b > 0);
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold

    return c;
  }

  /**
   * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
   */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b <= a);
    uint256 c = a - b;

    return c;
  }

  /**
   * @dev Adds two unsigned integers, reverts on overflow.
   */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a);

    return c;
  }

  /**
   * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
   * reverts when dividing by zero.
   */
  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b != 0);
    return a % b;
  }
}

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://eips.ethereum.org/EIPS/eip-20
 * Originally based on code by FirstBlood:
 * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 *
 * This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
 * all accounts just by listening to said events. Note that this isn't required by the specification, and other
 * compliant implementations may not do it.
 */
contract ERC20 is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) internal _balances;

    mapping (address => mapping (address => uint256)) private _allowed;

    /**
     * @dev Gets the balance of the specified address.
     * @param owner The address to query the balance of.
     * @return A uint256 representing the amount owned by the passed adfunction transferdress.
     */
    function balanceOf(address owner) public view returns (uint256) {
        return _balances[owner];
    }

    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     * @param owner address The address which owns the funds.
     * @param spender address The address which will spend the funds.
     * @return A uint256 specifying the amount of tokens still available for the spender.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowed[owner][spender];
    }

    /**
     * @dev Transfer token to a specified address.
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function transfer(address to, uint256 value) public returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
     * Beware that changing an allowance with this method brings the risk that someone may use both the old
     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
     * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev Transfer tokens from one address to another.
     * Note that while this function emits an Approval event, this is not required as per the specification,
     * and other compliant implementations may not emit the event.
     * @param from address The address which you want to send tokens from
     * @param to address The address which you want to transfer to
     * @param value uint256 the amount of tokens to be transferred
     */
    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        _transfer(from, to, value);
        _approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
        return true;
    }

    /**
     * @dev Increase the amount of tokens that an owner allowed to a spender.
     * approve should be called when _allowed[msg.sender][spender] == 0. To increment
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param addedValue The amount of tokens to increase the allowance by.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Decrease the amount of tokens that an owner allowed to a spender.
     * approve should be called when _allowed[msg.sender][spender] == 0. To decrement
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
        return true;
    }

    /**
     * @dev Transfer token for a specified addresses.
     * @param from The address to transfer from.
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function _transfer(address from, address to, uint256 value) internal {
        require(to != address(0));

        _balances[from] = _balances[from].sub(value);
        _balances[to] = _balances[to].add(value);
        emit Transfer(from, to, value);
    }

    /**
     * @dev Approve an address to spend another addresses' tokens.
     * @param owner The address that owns the tokens.
     * @param spender The address that will spend the tokens.
     * @param value The number of tokens that can be spent.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        require(spender != address(0));
        require(owner != address(0));

        _allowed[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

}

contract DABANKING is ERC20 {
  string public constant name = 'DABANKING';
  string public constant symbol = 'DAB';
  uint8 public constant decimals = 18;
  uint256 public constant totalSupply = (200 * 1e6) * (10 ** uint256(decimals));

  constructor(address _daBank) public {
    _balances[_daBank] = totalSupply;
    emit Transfer(address(0x0), _daBank, totalSupply);
  }
}

pragma solidity 0.4.25;

/**
 * @title ERC20 interface
 * @dev see https://eips.ethereum.org/EIPS/eip-20
 */
contract IERC20 {
    function transfer(address to, uint256 value) public returns (bool);

    function approve(address spender, uint256 value) public returns (bool);

    function transferFrom(address from, address to, uint256 value) public returns (bool);

    function balanceOf(address who) public view returns (uint256);

    function allowance(address owner, address spender) public view returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract Auth {
  address internal backupAdmin;
  address internal mainAdmin;
  address internal contractAdmin;
  address internal dabAdmin;
  address internal gemAdmin;
  address internal LAdmin;

  constructor(
    address _backupAdmin,
    address _mainAdmin,
    address _contractAdmin,
    address _dabAdmin,
    address _gemAdmin,
    address _LAdmin
  )
  internal
  {
    backupAdmin = _backupAdmin;
    mainAdmin = _mainAdmin;
    contractAdmin = _contractAdmin;
    dabAdmin = _dabAdmin;
    gemAdmin = _gemAdmin;
    LAdmin = _LAdmin;
  }

  modifier onlyBackupAdmin() {
    require(isBackupAdmin(), "onlyBackupAdmin");
    _;
  }

  modifier onlyMainAdmin() {
    require(isMainAdmin(), "onlyMainAdmin");
    _;
  }

  modifier onlyBackupOrMainAdmin() {
    require(isMainAdmin() || isBackupAdmin(), "onlyBackupOrMainAdmin");
    _;
  }

  modifier onlyContractAdmin() {
    require(isContractAdmin() || isMainAdmin(), "onlyContractAdmin");
    _;
  }

  modifier onlyLAdmin() {
    require(isLAdmin() || isMainAdmin(), "onlyLAdmin");
    _;
  }

  modifier onlyDABAdmin() {
    require(isDABAdmin() || isMainAdmin(), "onlyDABAdmin");
    _;
  }

  modifier onlyGEMAdmin() {
    require(isGEMAdmin() || isMainAdmin(), "onlyGEMAdmin");
    _;
  }

  function isBackupAdmin() public view returns (bool) {
    return msg.sender == backupAdmin;
  }

  function isMainAdmin() public view returns (bool) {
    return msg.sender == mainAdmin;
  }

  function isContractAdmin() public view returns (bool) {
    return msg.sender == contractAdmin;
  }

  function isLAdmin() public view returns (bool) {
    return msg.sender == LAdmin;
  }

  function isDABAdmin() public view returns (bool) {
    return msg.sender == dabAdmin;
  }

  function isGEMAdmin() public view returns (bool) {
    return msg.sender == gemAdmin;
  }
}

interface IContractNo2 {
  function adminCommission(uint _amount) external;

  function deposit(
    address _user,
    uint8 _type,
    uint packageAmount,
    uint _dabAmount,
    uint _gemAmount
  ) external;

  function getProfit(address _user, uint _stakingBalance) external returns (uint, uint);

  function getWithdraw(address _user, uint _stakingBalance, uint8 _type) external returns (uint, uint);

  function validateJoinPackage(
    address _user,
    address _to,
    uint8 _type,
    uint _dabAmount,
    uint _gemAmount
  ) external returns (bool);
}

interface IContractNo3 {

  function isCitizen(address _user) view external returns (bool);

  function register(address _user, string _userName, address _inviter) external returns (uint);

  function addF1M9DepositedToInviter(address _invitee, uint _amount) external;

  function checkInvestorsInTheSameReferralTree(address _inviter, address _invitee) external view returns (bool);

  function increaseInviterF1HaveJoinedPackage(address _invitee) external;

  function increaseInviterF1HaveJoinedM9Package(address _invitee) external;

  function addNetworkDepositedToInviter(address _inviter, uint _dabAmount, uint _gemAmount) external;

  function getF1M9Deposited(address _investor) external view returns (uint);

  function getDirectlyInviteeHaveJoinedM9Package(address _investor) external view returns (address[]);

  function getRank(address _investor) external view returns (uint8);

  function getInviter(address _investor) external view returns (address);

  function showInvestorInfo(address _investorAddress) external view returns (uint, string memory, address, address[],  address[],  address[], uint, uint, uint, uint, uint);
}

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error.
 */
library SafeMath {
  /**
   * @dev Multiplies two unsigned integers, reverts on overflow.
   */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b, 'SafeMath mul error');

    return c;
  }

  /**
   * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
   */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // Solidity only automatically asserts when dividing by 0
    require(b > 0, 'SafeMath div error');
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold

    return c;
  }

  /**
   * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
   */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b <= a, 'SafeMath sub error');
    uint256 c = a - b;

    return c;
  }

  /**
   * @dev Adds two unsigned integers, reverts on overflow.
   */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a, 'SafeMath add error');

    return c;
  }

  /**
   * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
   * reverts when dividing by zero.
   */
  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b != 0, 'SafeMath mod error');
    return a % b;
  }
}

contract ContractNo1 is Auth {
  using SafeMath for uint;

  enum PackageType {
    M0,
    M3,
    M6,
    M9,
    M12,
    M15,
    M18
  }

  enum WithdrawType {
    Half,
    Full
  }

  mapping(address => bool) public lAS;
  IERC20 public dabToken = IERC20(0x5E7Ebea68ab05198F771d77a875480314f1d0aae);
  IContractNo2 public contractNo2;
  IContractNo3 public contractNo3;

  uint public minJP = 5e18;
  uint8 public gemJPPercent = 30;

  event Registered(uint id, string userName, address userAddress, address inviter);
  event PackageJoined(address indexed from, address indexed to, PackageType packageType, uint dabAmount, uint gemAmount);
  event Profited(address indexed user, uint dabAmount, uint gemAmount);
  event Withdrew(address indexed user, uint dabAmount, uint gemAmount);

  constructor(
    address _backupAdmin,
    address _mainAdmin,
    address _dabAdmin,
    address _LAdmin
  )
  public
  Auth(
    _backupAdmin,
    _mainAdmin,
    msg.sender,
    _dabAdmin,
    address(0x0),
    _LAdmin
  ) {
  }

  // ADMINS FUNCTIONS

  function setC(address _c) onlyContractAdmin public {
    contractNo3 = IContractNo3(_c);
  }

  function setW(address _w) onlyContractAdmin public {
    contractNo2 = IContractNo2(_w);
  }

  function updateBackupAdmin(address _newBackupAdmin) onlyBackupAdmin public {
    require(_newBackupAdmin != address(0x0), 'Invalid address');
    backupAdmin = _newBackupAdmin;
  }

  function updateMainAdmin(address _newMainAdmin) onlyBackupOrMainAdmin public {
    require(_newMainAdmin != address(0x0), 'Invalid address');
    mainAdmin = _newMainAdmin;
  }

  function updateContractAdmin(address _newContractAdmin) onlyMainAdmin public {
    require(_newContractAdmin != address(0x0), 'Invalid address');
    contractAdmin = _newContractAdmin;
  }

  function updateDABAdmin(address _newDABAdmin) onlyMainAdmin public {
    require(_newDABAdmin != address(0x0), 'Invalid address');
    dabAdmin = _newDABAdmin;
  }

  function updateLockerAdmin(address _newLockerAdmin) onlyMainAdmin public {
    require(_newLockerAdmin != address(0x0), 'Invalid address');
    LAdmin = _newLockerAdmin;
  }

  function LA(address[] _values, bool _locked) onlyLAdmin public {
    require(_values.length > 0, 'Values cannot be empty');
    require(_values.length <= 256, 'Maximum is 256');
    for (uint8 i = 0; i < _values.length; i++) {
      require(_values[i] != msg.sender, 'Yourself!!!');
      lAS[_values[i]] = _locked;
    }
  }

  function setMinJP(uint _minJP) onlyMainAdmin public {
    require(_minJP > 0, 'Must be > 0');
    minJP = _minJP;
  }

  function setGemJP(uint8 _gemJPPercent) onlyMainAdmin public {
    require(0 < _gemJPPercent && _gemJPPercent < 101, 'Must be 1 - 100');
    gemJPPercent = _gemJPPercent;
  }

  // PUBLIC FUNCTIONS

  function register(string memory _userName, address _inviter) public {
    require(contractNo3.isCitizen(_inviter), 'Inviter did not registered');
    require(_inviter != msg.sender, 'Cannot referral yourself');
    uint id = contractNo3.register(msg.sender, _userName, _inviter);
    emit Registered(id, _userName, msg.sender, _inviter);
  }

  function showMe() public view returns (uint, string memory, address, address[], address[], address[], uint, uint, uint, uint, uint) {
    return contractNo3.showInvestorInfo(msg.sender);
  }

  function joinPackage(address _to, PackageType _type, uint _dabAmount, uint _gemAmount) public {
    uint packageAmount = _dabAmount.add(_gemAmount);
    validateJoinPackage(msg.sender, _to, _type, _dabAmount, _gemAmount);
    require(packageAmount >= minJP, 'Package amount must be greater min');
    require(dabToken.allowance(msg.sender, address(this)) >= _dabAmount, 'Please call approve() first');
    require(dabToken.balanceOf(msg.sender) >= _dabAmount, 'You have not enough funds');
    if (_gemAmount > 0) {
      uint8 gemPercent = uint8(_gemAmount.mul(100).div(packageAmount));
      require(gemPercent <= gemJPPercent, 'Too much GEM');
      contractNo2.adminCommission(_gemAmount.div(5));
    }

    require(dabToken.transferFrom(msg.sender, address(this), _dabAmount), 'Transfer token to contract failed');

    contractNo2.deposit(_to, uint8(_type), packageAmount, _dabAmount, _gemAmount);

    require(dabToken.transfer(dabAdmin, _dabAmount.div(5)), 'Transfer token to admin failed');

    emit PackageJoined(msg.sender, _to, _type, _dabAmount, _gemAmount);
  }

  function profit() public {
    require(!lAS[msg.sender], 'You can\'t do this now');
    uint dabProfit;
    uint gemProfit;
    (dabProfit, gemProfit) = contractNo2.getProfit(msg.sender, dabToken.balanceOf(address(this)));
    require(dabToken.transfer(msg.sender, dabProfit), 'Transfer profit to user failed');
    emit Profited(msg.sender, dabProfit, gemProfit);
  }

  function withdraw(WithdrawType _type) public {
    require(!lAS[msg.sender], 'You can\'t do this now');
    uint dabWithdrawable;
    uint gemWithdrawable;
    (dabWithdrawable, gemWithdrawable) = contractNo2.getWithdraw(msg.sender, dabToken.balanceOf(address(this)), uint8(_type));
    require(dabToken.transfer(msg.sender, dabWithdrawable), 'Transfer token to user failed');
    emit Withdrew(msg.sender, dabWithdrawable, gemWithdrawable);
  }

  // PRIVATE FUNCTIONS

  function validateJoinPackage(address _from, address _to, PackageType _type, uint _dabAmount, uint _gemAmount) private {
    require(contractNo3.isCitizen(_from), 'Please register first');
    require(contractNo3.isCitizen(_to), 'You can only active an exists member');
    if (_from != _to) {
      require(contractNo3.checkInvestorsInTheSameReferralTree(_from, _to), 'This user isn\'t in your referral tree');
    }
    require(contractNo2.validateJoinPackage(_from, _to, uint8(_type), _dabAmount, _gemAmount), 'Type or amount is invalid');
  }
}