// SPDX-License-Identifier: UNLICENSED

pragma solidity =0.8.18;

import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-ERC20PermitUpgradeable.sol";

import "./ERC20HistoryUpgradeable.sol";
import "./ERC20Guard.sol";
import "./SeizableSecurity.sol";

abstract contract ERC20Security is
    ERC20PausableUpgradeable,
    ERC20HistoryUpgradeable,
    ERC20PermitUpgradeable,
    SeizableSecurity,
    ERC20Guard
{
    function __ERC20Security_init(string memory domain, string memory name, string memory symbol)
        internal
        onlyInitializing
    {
        __ERC20Pausable_init_unchained();
        __Context_init_unchained();
        __Pausable_init_unchained();
        __ERC20History_init_unchained();
        __EIP712_init_unchained(domain, "1");
        __ERC20Permit_init_unchained(domain);
        __ERC165_init_unchained();
        __SeizableSecurity_init_unchained();
        __SomaContract_init_unchained();
        __Accessible_init_unchained();
        __Multicall_init_unchained();
        __Guardable__init_unchained();
        __ERC20Security_init_unchained();
        __ERC20_init_unchained(name, symbol);
    }

    function __ERC20Security_init_unchained() internal onlyInitializing {}

    function paused() public view virtual override(PausableUpgradeable, SomaContractUpgradeable) returns (bool) {
        return super.paused();
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(SeizableSecurity, ERC20Guard)
        returns (bool)
    {
        return interfaceId == type(IERC20Upgradeable).interfaceId
            || interfaceId == type(IERC20PermitUpgradeable).interfaceId
            || interfaceId == type(IERC20HistoryUpgradeable).interfaceId || super.supportsInterface(interfaceId);
    }

    function _mint(address to, uint256 amount) internal virtual override(ERC20Upgradeable, ERC20HistoryUpgradeable) {
        super._mint(to, amount);
    }

    function _burn(address from, uint256 amount) internal virtual override(ERC20Upgradeable, ERC20HistoryUpgradeable) {
        super._burn(from, amount);
    }

    function _afterTokenTransfer(address from, address to, uint256 amount)
        internal
        virtual
        override(ERC20Upgradeable, ERC20HistoryUpgradeable)
    {
        super._afterTokenTransfer(from, to, amount);
    }

    function _seize(address from, address to, uint256 amount) internal override {
        _transfer(from, to, amount);
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        virtual
        override(ERC20Upgradeable, ERC20PausableUpgradeable, ERC20Guard)
    {
        return super._beforeTokenTransfer(from, to, amount);
    }

    function _bypassValidate() internal virtual override returns (bool) {
        return (seizeInProgress) ? true : false;
    }

    uint256[50] private __gap;
}