// SPDX-License-Identifier: CC0-1.0
// VOVINA ZEDEC PRO — Singularity3 Dual-Space Edition
// Replaces the original Singularity3 contract. The "always-revert"
// functions are NOT bugs — they encode NEGATIVE_SPACE. This version
// keeps that semantics but harvests the revert reason as a
// deterministic side channel any caller can read off-chain.
//
//   Sections with axis offsets   {3, 6, 9}   → return uint256 (POSITIVE_SPACE)
//   Sections with doubling offsets {1,2,4,5,7,8} → revert(payload) (NEGATIVE_SPACE)
//
// Off-chain consumers use eth_call with revert decoding; on-chain
// callers use the `dualCall(...)` helper which catches the revert
// and returns both halves of the dual.

pragma solidity ^0.8.20;

contract Singularity3DualSpace {
    // ── Vortex topology, named ─────────────────────────────
    uint8[6] public VORTEX_DOUBLING_CIRCUIT = [1, 2, 4, 8, 7, 5];
    uint8[3] public VORTEX_369_AXIS         = [3, 6, 9];

    // ── Identity ───────────────────────────────────────────
    address public immutable singularityOrigin;
    string  public constant  sacredFormula = "all=9=magick=Michael_Laurence_Curzi=TRUE";

    // ── Sections (mirror, offset, base) ───────────────────
    struct Section {
        uint16 mirror;       // 369 / 693 / 936
        uint8  offset;       // 1..9
        bool   isAxis;       // true ⇔ offset ∈ {3, 6, 9}
    }
    Section[9] public sections;

    // ── Events ─────────────────────────────────────────────
    event ZeroPointPulse(address indexed origin, uint256 timestamp, bytes32 hash);
    event PositiveSpaceReturn(uint8 section, uint8 fn, uint256 value);
    event NegativeSpacePayload(uint8 section, uint8 fn, string payload);

    constructor() {
        singularityOrigin = msg.sender;
        // Section i has offset (i+1), mirror cycling through {693,936,369}
        uint16[3] memory mirrors = [uint16(693), uint16(936), uint16(369)];
        for (uint8 i = 0; i < 9; i++) {
            uint8 offset = i + 1;
            sections[i] = Section({
                mirror: mirrors[i % 3],
                offset: offset,
                isAxis: (offset == 3 || offset == 6 || offset == 9)
            });
        }
        emit ZeroPointPulse(msg.sender, block.timestamp,
            keccak256(abi.encodePacked("SINGULARITY_ORIGIN")));
    }

    // ── Polarity oracle ────────────────────────────────────
    function polarityOf(uint8 sectionIndex) public view returns (string memory) {
        require(sectionIndex < 9, "section index out of range");
        return sections[sectionIndex].isAxis ? "POSITIVE_SPACE" : "NEGATIVE_SPACE";
    }

    // ── Section function: positive-space path ─────────────
    function _positiveValue(uint8 sectionIndex, uint8 multiplier) internal view returns (uint256) {
        Section memory s = sections[sectionIndex];
        return (uint256(s.mirror) * uint256(multiplier) + uint256(s.offset)) % 999_999;
    }

    /// @notice Read the section/function pair. POSITIVE_SPACE returns a value;
    ///         NEGATIVE_SPACE reverts with a structured payload.
    /// @dev    The revert is intentional. Off-chain or via dualCall() the
    ///         payload is a deterministic data channel, not an error.
    function sectionFunction(uint8 sectionIndex, uint8 multiplier)
        public view returns (uint256)
    {
        require(sectionIndex < 9, "section index out of range");
        require(multiplier >= 1 && multiplier <= 8, "multiplier must be 1..8");
        Section memory s = sections[sectionIndex];
        uint256 raw = uint256(s.mirror) * uint256(multiplier) + uint256(s.offset);

        if (raw % 9 == 0 || raw % 3 == 0) {
            // POSITIVE_SPACE — axis-aligned, returns the value
            return raw % 999_999;
        }
        // NEGATIVE_SPACE — doubling-circuit, reverts with payload
        bytes memory payload = abi.encodePacked(
            "VORTEX:NEG:section=", _u8ToStr(sectionIndex + 1),
            ":fn=",                _u8ToStr(multiplier),
            ":offset=",            _u8ToStr(s.offset),
            ":mirror=",            _u16ToStr(s.mirror),
            ":raw=",               _u256ToStr(raw),
            ":complement=",        _u8ToStr(9 - s.offset),
            ":doubling=124875"
        );
        revert(string(payload));
    }

    // ── On-chain dual reader (harvests both halves atomically) ──
    /// @notice Call sectionFunction(...) and return BOTH the positive value
    ///         (if any) and the negative-space payload (if the call reverted).
    ///         Exactly one of (positiveValid, negativePayload) is meaningful.
    function dualCall(uint8 sectionIndex, uint8 multiplier)
        public view
        returns (bool positiveValid, uint256 positiveValue, string memory negativePayload)
    {
        try this.sectionFunction(sectionIndex, multiplier) returns (uint256 v) {
            return (true, v, "");
        } catch Error(string memory reason) {
            return (false, 0, reason);
        } catch (bytes memory) {
            return (false, 0, "VORTEX:NEG:UNKNOWN_PANIC");
        }
    }

    // ── Whole-table sweep (positive + negative, all 72 cells) ──
    /// @notice Return the 24 positive-space values and the 48
    ///         negative-space payloads as separate arrays.
    function sweepDualTable()
        external view
        returns (uint256[24] memory positives, string[48] memory negatives)
    {
        uint8 pIdx = 0;
        uint8 nIdx = 0;
        for (uint8 s = 0; s < 9; s++) {
            for (uint8 m = 1; m <= 8; m++) {
                (bool ok, uint256 v, string memory neg) = dualCall(s, m);
                if (ok) {
                    positives[pIdx++] = v;
                } else {
                    negatives[nIdx++] = neg;
                }
            }
        }
    }

    // ── 3-6-9 resonance check ──────────────────────────────
    function resonanceCheck() public pure returns (bool) {
        return (369 + 693 + 936) % 9 == 0;            // true
    }

    // ── Small uint→string helpers (avoid SafeCast dependency) ──
    function _u8ToStr(uint8 v) internal pure returns (string memory) {
        return _u256ToStr(uint256(v));
    }
    function _u16ToStr(uint16 v) internal pure returns (string memory) {
        return _u256ToStr(uint256(v));
    }
    function _u256ToStr(uint256 v) internal pure returns (string memory) {
        if (v == 0) return "0";
        uint256 t = v;
        uint256 digits;
        while (t != 0) { digits++; t /= 10; }
        bytes memory buf = new bytes(digits);
        while (v != 0) {
            digits -= 1;
            buf[digits] = bytes1(uint8(48 + v % 10));
            v /= 10;
        }
        return string(buf);
    }
}