pragma solidity ^0.4.24;


contract EnumThresholdTypes {
    enum ThresholdTypes {Invalid, Keys, MetadataChange}
}


contract EnumKeyTypes {
    enum KeyTypes {Invalid, MiningKey, VotingKey, PayoutKey}
}


contract EnumBallotTypes {
    enum BallotTypes {
        Invalid,
        KeyAdding,
        KeyRemoval,
        KeySwap,
        MinThreshold,
        ProxyAddress,
        ManageEmissionFunds
    }
}


/**
 * @title EternalStorage
 * @dev This contract holds all the necessary state variables to carry out the storage of any contract
 * and to support the upgrade functionality.
 */
contract EternalStorage {

    // Version number of the current implementation
    uint256 internal _version;

    // Address of the current implementation
    address internal _implementation;

    // Storage mappings
    mapping(bytes32 => uint256) internal uintStorage;
    mapping(bytes32 => string) internal stringStorage;
    mapping(bytes32 => address) internal addressStorage;
    mapping(bytes32 => bytes) internal bytesStorage;
    mapping(bytes32 => bool) internal boolStorage;
    mapping(bytes32 => int256) internal intStorage;
    mapping(bytes32 => bytes32) internal bytes32Storage;

    mapping(bytes32 => uint256[]) internal uintArrayStorage;
    mapping(bytes32 => string[]) internal stringArrayStorage;
    mapping(bytes32 => address[]) internal addressArrayStorage;
    //mapping(bytes32 => bytes[]) internal bytesArrayStorage;
    mapping(bytes32 => bool[]) internal boolArrayStorage;
    mapping(bytes32 => int256[]) internal intArrayStorage;
    mapping(bytes32 => bytes32[]) internal bytes32ArrayStorage;

}



interface IPoaNetworkConsensus {
    function addValidator(address, bool) external returns(bool);
    function finalizeChange() external;
    function removeValidator(address, bool) external returns(bool);
    function swapValidatorKey(address, address) external returns(bool);
    function isMasterOfCeremonyRemoved() external view returns(bool);
    function isValidator(address) external view returns(bool);
    function getCurrentValidatorsLength() external view returns(uint256);
    function getCurrentValidatorsLengthWithoutMoC() external view returns(uint256);
    function getPendingList() external view returns(address[]);
    function getValidators() external view returns(address[]);
    function masterOfCeremony() external view returns(address);
}


interface IPoaNetworkConsensusForVotingToChange {
    function currentValidators(uint256) external view returns(address);
    function getCurrentValidatorsLength() external view returns(uint256);
}


interface IProxyStorage {
    function initializeAddresses(
        address, address, address, address, address, address, address, address
    ) external;

    function setContractAddress(uint256, address) external returns(bool);
    function getBallotsStorage() external view returns(address);
    function getKeysManager() external view returns(address);
    function getPoaConsensus() external view returns(address);
    function getValidatorMetadata() external view returns(address);
    function getVotingToChangeKeys() external view returns(address);
    function getVotingToChangeMinThreshold() external view returns(address);
}


interface IKeysManager {
    function addMiningKey(address) external returns(bool);
    function addVotingKey(address, address) external returns(bool);
    function addPayoutKey(address, address) external returns(bool);
    function createKeys(address, address, address) external;
    function initiateKeys(address) external;
    function migrateInitialKey(address) external;
    function migrateMiningKey(address) external;
    function removeMiningKey(address) external returns(bool);
    function removeVotingKey(address) external returns(bool);
    function removePayoutKey(address) external returns(bool);
    function swapMiningKey(address, address) external returns(bool);
    function swapVotingKey(address, address) external returns(bool);
    function swapPayoutKey(address, address) external returns(bool);
    function checkIfMiningExisted(address, address) external view returns(bool);
    function initialKeysCount() external view returns(uint256);
    function isMiningActive(address) external view returns(bool);
    function isVotingActive(address) external view returns(bool);
    function isPayoutActive(address) external view returns(bool);
    function hasMiningKeyBeenRemoved(address) external view returns(bool);
    function getVotingByMining(address) external view returns(address);
    function getPayoutByMining(address) external view returns(address);
    function getTime() external view returns(uint256);
    function getMiningKeyHistory(address) external view returns(address);
    function getMiningKeyByVoting(address) external view returns(address);
    function getInitialKeyStatus(address) external view returns(uint256);
    function masterOfCeremony() external view returns(address);
    function maxOldMiningKeysDeepCheck() external pure returns(uint256);
    function miningKeyByPayout(address) external view returns(address);
    function miningKeyByVoting(address) external view returns(address);
}


interface IKeysManagerPrev {
    function getInitialKey(address) external view returns(uint8);
}


interface IBallotsStorage {
    function setThreshold(uint256, uint256) external returns(bool);
    function areKeysBallotParamsValid(uint256, uint256, address, address) external view returns(bool);
    function getBallotThreshold(uint256) external view returns(uint256);
    function getVotingToChangeThreshold() external view returns(address);
    function getProxyThreshold() external view returns(uint256);
    function getBallotLimitPerValidator() external view returns(uint256);
    function getMaxLimitBallot() external view returns(uint256);
    function metadataChangeConfirmationsLimit() external pure returns(uint256);
}


interface IBallotsStoragePrev {
    function getBallotThreshold(uint8) external view returns(uint256);
}












/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns(uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        assert(c / a == b);
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns(uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns(uint256) {
        assert(b <= a);
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns(uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}



contract BallotsStorage is EternalStorage, EnumBallotTypes, EnumKeyTypes, EnumThresholdTypes, IBallotsStorage {
    using SafeMath for uint256;

    bytes32 internal constant INIT_DISABLED = keccak256("initDisabled");
    bytes32 internal constant OWNER = keccak256("owner");
    bytes32 internal constant PROXY_STORAGE = keccak256("proxyStorage");

    bytes32 internal constant BALLOT_THRESHOLDS = "ballotThresholds";

    event ThresholdChanged(uint256 indexed thresholdType, uint256 newValue);

    modifier onlyOwner() {
        require(msg.sender == addressStorage[OWNER]);
        _;
    }

    modifier onlyVotingToChangeThreshold() {
        require(msg.sender == getVotingToChangeThreshold());
        _;
    }

    function areKeysBallotParamsValid(
        uint256 _ballotType,
        uint256 _affectedKeyType,
        address _affectedKey,
        address _miningKey
    ) external view returns(bool) {
        require(_ballotType >= uint256(BallotTypes.KeyAdding));
        require(_ballotType <= uint256(BallotTypes.KeySwap));
        require(_affectedKey != address(0));
        require(_affectedKeyType >= uint256(KeyTypes.MiningKey));
        require(_affectedKeyType <= uint256(KeyTypes.PayoutKey));

        if (_ballotType == uint256(BallotTypes.KeyAdding)) {
            return _areKeyAddingBallotParamsValid(
                _affectedKeyType, 
                _affectedKey,
                _miningKey
            );
        }
        if (_ballotType == uint256(BallotTypes.KeyRemoval)) {
            return _areKeyRemovalBallotParamsValid(
                _affectedKeyType,
                _affectedKey,
                _miningKey
            );
        }
        if (_ballotType == uint256(BallotTypes.KeySwap)) {
            return _areKeySwapBallotParamsValid(
                _affectedKeyType,
                _affectedKey,
                _miningKey
            );
        }
    }

    function proxyStorage() public view returns(address) {
        return addressStorage[PROXY_STORAGE];
    }

    function initDisabled() public view returns(bool) {
        return boolStorage[INIT_DISABLED];
    }

    function init(
        uint256[] _thresholds
    ) public onlyOwner {
        require(!initDisabled());
        require(_thresholds.length == uint256(ThresholdTypes.MetadataChange));
        uint256 thresholdType = uint256(ThresholdTypes.Keys);
        for (; thresholdType <= _thresholds.length; thresholdType++) {
            uint256 thresholdValue = _thresholds[thresholdType - uint256(ThresholdTypes.Keys)];
            if (!_setThreshold(thresholdValue, thresholdType)) {
                revert();
            }
        }
        _initDisable();
    }

    function metadataChangeConfirmationsLimit() public pure returns(uint256) {
        return 50;
    }

    function migrate(address _prevBallotsStorage) public onlyOwner {
        require(_prevBallotsStorage != address(0));
        require(!initDisabled());
        uint8 thresholdKeysType = uint8(ThresholdTypes.Keys);
        uint8 thresholdMetadataType = uint8(ThresholdTypes.MetadataChange);
        IBallotsStoragePrev prevBallotsStorage = IBallotsStoragePrev(_prevBallotsStorage);
        if (!_setThreshold(prevBallotsStorage.getBallotThreshold(thresholdKeysType), thresholdKeysType)) {
            revert();
        }
        if (!_setThreshold(prevBallotsStorage.getBallotThreshold(thresholdMetadataType), thresholdMetadataType)) {
            revert();
        }
        _initDisable();
    }

    function setThreshold(uint256 _newValue, uint256 _thresholdType)
        public
        onlyVotingToChangeThreshold
        returns(bool)
    {
        if (_newValue == getBallotThreshold(_thresholdType)) return false;
        if (!_setThreshold(_newValue, _thresholdType)) return false;
        emit ThresholdChanged(_thresholdType, _newValue);
        return true;
    }

    function getBallotThreshold(uint256 _ballotType) public view returns(uint256) {
        return uintStorage[keccak256(abi.encode(BALLOT_THRESHOLDS, _ballotType))];
    }

    function getVotingToChangeThreshold() public view returns(address) {
        return IProxyStorage(proxyStorage()).getVotingToChangeMinThreshold();
    }

    function getProxyThreshold() public view returns(uint256) {
        return _getTotalNumberOfValidators().div(2).add(1);
    }

    function getBallotLimitPerValidator() public view returns(uint256) {
        uint256 validatorsCount = _getTotalNumberOfValidators();
        if (validatorsCount == 0) {
            return getMaxLimitBallot();
        }
        uint256 limit = getMaxLimitBallot().div(validatorsCount);
        if (limit == 0) {
            limit = 1;
        }
        return limit;
    }
    
    function getMaxLimitBallot() public view returns(uint256) {
        return 200;
    }

    function _areKeyAddingBallotParamsValid(
        uint256 _affectedKeyType,
        address _affectedKey,
        address _miningKey
    ) internal view returns(bool) {
        IKeysManager keysManager = _getKeysManager();
        if (_affectedKeyType == uint256(KeyTypes.MiningKey)) {
            return !keysManager.checkIfMiningExisted(_miningKey, _affectedKey);
        }
        if (_affectedKeyType == uint256(KeyTypes.VotingKey)) {
            require(_miningKey != keysManager.masterOfCeremony());
            require(keysManager.miningKeyByVoting(_affectedKey) == address(0));
            return _affectedKey != _miningKey && keysManager.isMiningActive(_miningKey);
        }
        if (_affectedKeyType == uint256(KeyTypes.PayoutKey)) {
            require(keysManager.miningKeyByPayout(_affectedKey) == address(0));
            return _affectedKey != _miningKey && keysManager.isMiningActive(_miningKey);
        }
    }

    function _areKeyRemovalBallotParamsValid(
        uint256 _affectedKeyType,
        address _affectedKey,
        address _miningKey
    ) internal view returns(bool) {
        IKeysManager keysManager = _getKeysManager();
        require(keysManager.isMiningActive(_miningKey));
        if (_affectedKeyType == uint256(KeyTypes.MiningKey)) {
            return true;
        }
        if (_affectedKeyType == uint256(KeyTypes.VotingKey)) {
            require(_affectedKey != _miningKey);
            address votingKey = keysManager.getVotingByMining(_miningKey);
            require(_affectedKey == votingKey);
            return keysManager.isVotingActive(votingKey);
        }
        if (_affectedKeyType == uint256(KeyTypes.PayoutKey)) {
            require(_affectedKey != _miningKey);
            address payoutKey = keysManager.getPayoutByMining(_miningKey);
            require(_affectedKey == payoutKey);
            return keysManager.isPayoutActive(_miningKey);
        }
    }

    function _areKeySwapBallotParamsValid(
        uint256 _affectedKeyType,
        address _affectedKey,
        address _miningKey
    ) internal view returns(bool) {
        require(_affectedKey != _miningKey);
        IKeysManager keysManager = _getKeysManager();
        require(keysManager.isMiningActive(_miningKey));
        if (_affectedKeyType == uint256(KeyTypes.MiningKey)) {
            return !keysManager.checkIfMiningExisted(_miningKey, _affectedKey);
        }
        if (_affectedKeyType == uint256(KeyTypes.VotingKey)) {
            address votingKey = keysManager.getVotingByMining(_miningKey);
            require(_affectedKey != votingKey);
            require(keysManager.miningKeyByVoting(_affectedKey) == address(0));
            return keysManager.isVotingActive(votingKey);
        }
        if (_affectedKeyType == uint256(KeyTypes.PayoutKey)) {
            address payoutKey = keysManager.getPayoutByMining(_miningKey);
            require(_affectedKey != payoutKey);
            require(keysManager.miningKeyByPayout(_affectedKey) == address(0));
            return keysManager.isPayoutActive(_miningKey);
        }
    }

    function _initDisable() internal {
        boolStorage[INIT_DISABLED] = true;
    }

    function _getKeysManager() internal view returns(IKeysManager) {
        return IKeysManager(IProxyStorage(proxyStorage()).getKeysManager());
    }

    function _getTotalNumberOfValidators() internal view returns(uint256) {
        IProxyStorage proxy = IProxyStorage(proxyStorage());
        IPoaNetworkConsensus poa = IPoaNetworkConsensus(proxy.getPoaConsensus());
        return poa.getCurrentValidatorsLengthWithoutMoC();
    }

    function _setThreshold(uint256 _newValue, uint256 _thresholdType) internal returns(bool) {
        if (_newValue == 0) return false;
        if (_thresholdType == uint256(ThresholdTypes.Invalid)) return false;
        if (_thresholdType > uint256(ThresholdTypes.MetadataChange)) return false;
        if (_thresholdType == uint256(ThresholdTypes.MetadataChange)) {
            if (_newValue > metadataChangeConfirmationsLimit()) {
                return false;
            }
        }
        uintStorage[
            keccak256(abi.encode(BALLOT_THRESHOLDS, _thresholdType))
        ] = _newValue;
        return true;
    }
}