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

/**
 * @title Aeterna Sovereign Dollar (AET-USD)
 * @notice High-End Institutional Asset-Backed Payment & Clearing Stablecoin
 * @dev Combines ERC-20, EIP-2612 Gasless Permits, ERC-3643 (T-REX) Institutional
 *      Identity Gating, Transparent Proxy Upgradeability, and Basel III Group 1b Compliance.
 */

abstract contract Initializable {
    uint8 private _initialized;
    bool private _initializing;

    event Initialized(uint8 version);

    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!Address.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }
}

library Address {
    function isContract(address account) internal view returns (bool) {
        return account.code.length > 0;
    }
}

interface IIdentityRegistry {
    function isVerified(address _userAddress) external view returns (bool);
}

contract AeternaSovereignDollar is Initializable {
    // --- Token Parameters ---
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;

    // --- State Storage ---
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    // --- Institutional & Governance Roles ---
    address public owner;
    address public pendingOwner;
    address public masterMinter;
    address public complianceAdmin; // T-REX / Sanctions Officer
    address public pauser;
    address public custodyVault;   // Designated Qualified Custodian Vault

    // Identity Registry (ERC-3643 T-REX Standard)
    IIdentityRegistry public identityRegistry;
    bool public complianceGatingEnabled;

    // Permissions & Quotas
    mapping(address => bool) public minters;
    mapping(address => uint256) public minterAllowance;
    mapping(address => bool) public isFrozen;
    bool public paused;

    // EIP-2612 Gasless Permit Storage
    bytes32 public DOMAIN_SEPARATOR;
    mapping(address => uint256) public nonces;
    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;

    // ISO Identifiers
    bytes32 public constant ISO24165_DTI = 0x4145542D5553442D49534F2D4454490000000000000000000000000000000000;
    string public constant JURISDICTION_FILING = "WY-2026-002019968";

    // --- Events ---
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Mint(address indexed minter, address indexed to, uint256 amount);
    event Burn(address indexed burner, uint256 amount);
    event AddressFrozen(address indexed target, string reason);
    event AddressUnfrozen(address indexed target);
    event AssetConfiscated(address indexed target, uint256 amountWiped);
    event IdentityRegistryUpdated(address indexed newRegistry);
    event ComplianceGatingToggled(bool enabled);
    event CustodyVaultUpdated(address indexed newVault);
    event OwnershipTransferInitiated(address indexed previousOwner, address indexed newOwner);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event MinterRemoved(address indexed minter);

    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }

    modifier onlyCompliance() {
        require(msg.sender == complianceAdmin || msg.sender == owner, "Compliance: unauthorized");
        _;
    }

    modifier onlyMasterMinter() {
        require(msg.sender == masterMinter || msg.sender == owner, "Minter: unauthorized");
        _;
    }

    modifier whenNotPaused() {
        require(!paused, "Pausable: token transfers are paused");
        _;
    }

    modifier notFrozen(address account) {
        require(!isFrozen[account], "Compliance: address is frozen");
        _;
    }

    /**
     * @notice Initializer for Transparent Upgradeable Proxy
     */
    function initialize(
        string memory _name,
        string memory _symbol,
        uint8 _decimals,
        address _owner,
        address _masterMinter,
        address _complianceAdmin,
        address _pauser,
        address _custodyVault
    ) external initializer {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        owner = _owner;
        masterMinter = _masterMinter;
        complianceAdmin = _complianceAdmin;
        pauser = _pauser;
        custodyVault = _custodyVault;
        complianceGatingEnabled = false;

        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                keccak256(bytes(_name)),
                keccak256(bytes("1")),
                block.chainid,
                address(this)
            )
        );
    }

    // --- Views ---
    function balanceOf(address account) external view returns (uint256) {
        return _balances[account];
    }

    function allowance(address _owner, address _spender) external view returns (uint256) {
        return _allowances[_owner][_spender];
    }

    // --- Core Transfers with T-REX & Sanctions Validation ---
    function transfer(address to, uint256 amount)
        external
        whenNotPaused
        notFrozen(msg.sender)
        notFrozen(to)
        returns (bool)
    {
        _beforeTransfer(msg.sender, to, amount);
        _transfer(msg.sender, to, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount)
        external
        whenNotPaused
        notFrozen(msg.sender)
        notFrozen(from)
        notFrozen(to)
        returns (bool)
    {
        uint256 currentAllowance = _allowances[from][msg.sender];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(from, msg.sender, currentAllowance - amount);
        }

        _beforeTransfer(from, to, amount);
        _transfer(from, to, amount);
        return true;
    }

    function approve(address spender, uint256 amount)
        external
        whenNotPaused
        notFrozen(msg.sender)
        notFrozen(spender)
        returns (bool)
    {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function _beforeTransfer(address from, address to, uint256) internal view {
        if (complianceGatingEnabled && address(identityRegistry) != address(0)) {
            if (from != address(0)) {
                require(identityRegistry.isVerified(from), "T-REX: sender failed on-chain identity KYC");
            }
            if (to != address(0)) {
                require(identityRegistry.isVerified(to), "T-REX: recipient failed on-chain identity KYC");
            }
        }
    }

    function _transfer(address from, address to, uint256 amount) internal {
        require(from != address(0), "ERC20: transfer from zero");
        require(to != address(0), "ERC20: transfer to zero");

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: balance insufficient");
        unchecked {
            _balances[from] = fromBalance - amount;
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);
    }

    function _approve(address _owner, address _spender, uint256 amount) internal {
        require(_owner != address(0), "ERC20: zero owner");
        require(_spender != address(0), "ERC20: zero spender");
        _allowances[_owner][_spender] = amount;
        emit Approval(_owner, _spender, amount);
    }

    // --- Institutional Minting & Burning ---
    function configureMinter(address minter, uint256 quota) external onlyMasterMinter {
        minters[minter] = true;
        minterAllowance[minter] = quota;
    }

    function removeMinter(address minter) external onlyMasterMinter {
        require(minters[minter], "Not an active minter");
        minters[minter] = false;
        minterAllowance[minter] = 0;
        emit MinterRemoved(minter);
    }

    function mint(address to, uint256 amount) external whenNotPaused notFrozen(to) returns (bool) {
        require(minters[msg.sender] || msg.sender == owner, "Unauthorized minter");
        if (msg.sender != owner) {
            require(minterAllowance[msg.sender] >= amount, "Quota exceeded");
            minterAllowance[msg.sender] -= amount;
        }

        totalSupply += amount;
        _balances[to] += amount;

        emit Mint(msg.sender, to, amount);
        emit Transfer(address(0), to, amount);
        return true;
    }

    function burn(uint256 amount) external whenNotPaused {
        uint256 balance = _balances[msg.sender];
        require(balance >= amount, "Insufficient burn balance");

        _balances[msg.sender] = balance - amount;
        totalSupply -= amount;

        emit Burn(msg.sender, amount);
        emit Transfer(msg.sender, address(0), amount);
    }

    // --- Law Enforcement & Sanctions Intercept ---
    function freeze(address target, string calldata reason) external onlyCompliance {
        isFrozen[target] = true;
        emit AddressFrozen(target, reason);
    }

    function unfreeze(address target) external onlyCompliance {
        isFrozen[target] = false;
        emit AddressUnfrozen(target);
    }

    function wipeAccount(address target) external onlyCompliance {
        require(isFrozen[target], "Target not frozen");
        uint256 dirtyFunds = _balances[target];
        require(dirtyFunds > 0, "No balance");

        _balances[target] = 0;
        totalSupply -= dirtyFunds;

        emit AssetConfiscated(target, dirtyFunds);
        emit Transfer(target, address(0), dirtyFunds);
    }

    // --- EIP-2612 Gasless Permit ---
    function permit(
        address _owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external whenNotPaused notFrozen(_owner) notFrozen(spender) {
        require(block.timestamp <= deadline, "Permit expired");

        bytes32 structHash = keccak256(
            abi.encode(PERMIT_TYPEHASH, _owner, spender, value, nonces[_owner]++, deadline)
        );
        bytes32 hash = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, structHash));
        address signer = ecrecover(hash, v, r, s);
        require(signer != address(0) && signer == _owner, "Invalid signature");

        _approve(_owner, spender, value);
    }

    // --- T-REX & Governance Config ---
    function setIdentityRegistry(address _registry) external onlyOwner {
        identityRegistry = IIdentityRegistry(_registry);
        emit IdentityRegistryUpdated(_registry);
    }

    function toggleComplianceGating(bool enabled) external onlyOwner {
        complianceGatingEnabled = enabled;
        emit ComplianceGatingToggled(enabled);
    }

    function setCustodyVault(address _vault) external onlyOwner {
        custodyVault = _vault;
        emit CustodyVaultUpdated(_vault);
    }

    function setPaused(bool _paused) external {
        require(msg.sender == pauser || msg.sender == owner, "Unauthorized pauser");
        paused = _paused;
    }

    // --- Two-Step Ownership Transfer ---
    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "Zero address");
        require(newOwner != owner, "Current owner");
        pendingOwner = newOwner;
        emit OwnershipTransferInitiated(owner, newOwner);
    }

    function acceptOwnership() external {
        require(msg.sender == pendingOwner, "Caller not pending owner");
        address previousOwner = owner;
        owner = pendingOwner;
        pendingOwner = address(0);
        emit OwnershipTransferred(previousOwner, owner);
    }
}