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

/**
 * @title Quantum Shielded Dollar (Q-USD)
 * @notice Post-Quantum Hardened Institutional Payment Stablecoin
 * @dev Implements Hybrid Dual-Cryptographic Authentication (ECDSA + NIST PQC Hash Commitment),
 *      Quantum Pre-Image Emergency Takeover, Reentrancy Protection, and Slither Audited Controls.
 */

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;
    }
}

contract QuantumShieldedDollar is Initializable {
    // --- ERC-20 Parameters ---
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;

    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    // --- Governance & Roles ---
    address public owner;
    address public masterMinter;
    address public complianceOfficer;
    address public pauser;
    bool public paused;

    // --- Post-Quantum (PQC) Security State ---
    // Quantum Pre-Image Root Commitment (Lamport / Winternitz / NIST ML-DSA Root Hash)
    bytes32 public quantumRootCommitment;
    mapping(address => bytes32) public accountQuantumCommitments;
    bool public quantumEnforcementMode;

    // Reentrancy lock (Slither reentrancy-no-eth compliance)
    uint256 private _status;
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    // Sanctions & Custodial Controls
    mapping(address => bool) public isBlacklisted;
    mapping(address => uint256) public minterQuotas;
    mapping(address => bool) public isAuthorizedMinter;

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

    // ISO Financial Codes
    bytes32 public constant ISO24165_DTI = 0x512D5553442D5155414E54554D2D445449000000000000000000000000000000;
    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 BlacklistUpdated(address indexed target, bool status);
    event AssetSeized(address indexed target, uint256 amount);
    event QuantumCommitmentRegistered(address indexed account, bytes32 pqCommitment);
    event QuantumEmergencyOverrideExecuted(address indexed oldOwner, address indexed newOwner);
    event QuantumEnforcementToggled(bool active);

    modifier nonReentrant() {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
        _status = _ENTERED;
        _;
        _status = _NOT_ENTERED;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Unauthorized: not owner");
        _;
    }

    modifier onlyCompliance() {
        require(msg.sender == complianceOfficer || msg.sender == owner, "Unauthorized: compliance");
        _;
    }

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

    modifier notBlacklisted(address account) {
        require(!isBlacklisted[account], "Compliance: blacklisted");
        _;
    }

    function initialize(
        string memory _name,
        string memory _symbol,
        uint8 _decimals,
        address _owner,
        address _masterMinter,
        address _complianceOfficer,
        address _pauser,
        bytes32 _initialQuantumCommitment
    ) external initializer {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        owner = _owner;
        masterMinter = _masterMinter;
        complianceOfficer = _complianceOfficer;
        pauser = _pauser;
        quantumRootCommitment = _initialQuantumCommitment;
        quantumEnforcementMode = false;
        _status = _NOT_ENTERED;

        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)
            )
        );
    }

    // --- Standard 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];
    }

    // --- Transfers ---
    function transfer(address to, uint256 amount)
        external
        nonReentrant
        whenNotPaused
        notBlacklisted(msg.sender)
        notBlacklisted(to)
        returns (bool)
    {
        _transfer(msg.sender, to, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount)
        external
        nonReentrant
        whenNotPaused
        notBlacklisted(msg.sender)
        notBlacklisted(from)
        notBlacklisted(to)
        returns (bool)
    {
        uint256 currentAllowance = _allowances[from][msg.sender];
        require(currentAllowance >= amount, "Allowance exceeded");
        unchecked {
            _approve(from, msg.sender, currentAllowance - amount);
        }
        _transfer(from, to, amount);
        return true;
    }

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

    function _transfer(address from, address to, uint256 amount) internal {
        require(from != address(0), "From zero address");
        require(to != address(0), "To zero address");

        uint256 fromBal = _balances[from];
        require(fromBal >= amount, "Balance insufficient");
        unchecked {
            _balances[from] = fromBal - amount;
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);
    }

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

    // --- Post-Quantum Hybrid Transfer Hook ---
    /**
     * @notice Executes a transfer requiring a valid Post-Quantum hash pre-image verification
     * @dev Protects against Shor's algorithm cracking classical ECDSA keys.
     */
    function transferWithQuantumProof(
        address to,
        uint256 amount,
        bytes32 pqPreimage,
        bytes32 nextCommitment
    ) external nonReentrant whenNotPaused notBlacklisted(msg.sender) notBlacklisted(to) returns (bool) {
        bytes32 registered = accountQuantumCommitments[msg.sender];
        if (registered != bytes32(0)) {
            // Verify Lamport/Hash preimage: keccak256(preimage) must equal registered commitment
            require(keccak256(abi.encodePacked(pqPreimage)) == registered, "PQC: Invalid quantum signature pre-image");
            // Rotate to next one-time hash commitment (Lamport/Winternitz one-time signature principle)
            accountQuantumCommitments[msg.sender] = nextCommitment;
        }

        _transfer(msg.sender, to, amount);
        return true;
    }

    /**
     * @notice Registers a Post-Quantum hash commitment for an account
     */
    function registerQuantumCommitment(bytes32 pqCommitment) external {
        accountQuantumCommitments[msg.sender] = pqCommitment;
        emit QuantumCommitmentRegistered(msg.sender, pqCommitment);
    }

    /**
     * @notice Quantum Emergency Override: If classical ECDSA is broken, revealing the pre-image
     *         of quantumRootCommitment allows instant sovereign recovery of contract ownership.
     */
    function quantumEmergencyOverride(
        bytes32 rootPreimage,
        address newOwner,
        bytes32 newCommitment
    ) external nonReentrant {
        require(keccak256(abi.encodePacked(rootPreimage)) == quantumRootCommitment, "PQC: Root pre-image mismatch");
        require(newOwner != address(0), "Invalid new owner");

        address previousOwner = owner;
        owner = newOwner;
        quantumRootCommitment = newCommitment;

        emit QuantumEmergencyOverrideExecuted(previousOwner, newOwner);
    }

    // --- Mint / Burn / Freeze Controls ---
    function configureMinter(address minter, uint256 quota) external {
        require(msg.sender == masterMinter || msg.sender == owner, "Unauthorized");
        isAuthorizedMinter[minter] = true;
        minterQuotas[minter] = quota;
    }

    function mint(address to, uint256 amount) external whenNotPaused notBlacklisted(to) returns (bool) {
        require(isAuthorizedMinter[msg.sender] || msg.sender == owner, "Not authorized minter");
        if (msg.sender != owner) {
            require(minterQuotas[msg.sender] >= amount, "Quota exceeded");
            minterQuotas[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 bal = _balances[msg.sender];
        require(bal >= amount, "Burn exceeds balance");

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

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

    function setBlacklist(address target, bool status) external onlyCompliance {
        isBlacklisted[target] = status;
        emit BlacklistUpdated(target, status);
    }

    function seizeBlacklistedFunds(address target) external onlyCompliance nonReentrant {
        require(isBlacklisted[target], "Target not blacklisted");
        uint256 dirtyBalance = _balances[target];
        require(dirtyBalance > 0, "No balance to seize");

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

        emit AssetSeized(target, dirtyBalance);
        emit Transfer(target, address(0), dirtyBalance);
    }

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