// Create a promise
uint256 promiseId = promiseContract.create();

// Resolve with data
promiseContract.resolve(promiseId, abi.encode("result"));

// Or reject with error
promiseContract.reject(promiseId, abi.encode("error"));

// Check promise status
Promise.PromiseStatus status = promiseContract.status(promiseId);

// Share resolved promise to another chain
promiseContract.shareResolvedPromise(destinationChainId, promiseId);

// Transfer resolution rights to another chain
promiseContract.transferResolve(promiseId, destinationChainId, newResolverAddress);

// Create a promise that resolves after 100 seconds
uint256 timeoutId = setTimeoutContract.create(block.timestamp + 100);

// Later, anyone can resolve it once the time has passed
if (setTimeoutContract.canResolve(timeoutId)) {
    setTimeoutContract.resolve(timeoutId);
}

// Local callback registration
uint256 thenId = callbackContract.then(
    parentPromiseId, 
    targetContract, 
    targetContract.handleSuccess.selector
);

// Cross-chain callback registration
uint256 crossChainThenId = callbackContract.thenOn(
    destinationChainId,
    parentPromiseId,
    targetContract,
    targetContract.handleSuccess.selector
);

// Error handling callbacks
uint256 catchId = callbackContract.onReject(
    parentPromiseId,
    targetContract, 
    targetContract.handleError.selector
);

// Create callbacks for promises that exist on other chains
uint256 remoteCallbackId = callbackContract.then(
    remotePromiseId, // Promise ID from another chain
    targetContract,
    targetContract.handleSuccess.selector
);
// Callback will become resolvable when remote promise is shared to this chain

// Aggregate promises from multiple chains
uint256[] memory promises = new uint256[](3);
promises[0] = localPromise;
promises[1] = chainAPromise;  // From Chain A
promises[2] = chainBPromise;  // From Chain B

uint256 promiseAllId = promiseAllContract.create(promises);
// Resolves when all promises resolve, rejects on first failure

// Simulate accumulated fees on both chains
feeCollectorA.simulateAccumulatedFees(1000 ether);
feeCollectorB.simulateAccumulatedFees(500 ether);

// Start the periodic cycle
uint256 cycleId = cronScheduler.startPeriodicFeeCollection(
    3600, // Run every hour (interval in seconds)
    address(feeCollectorA),  // Chain A fee collector
    address(feeCollectorB),  // Chain B fee collector  
    address(feeBurner)       // Fee burner
);

function executeCycle(uint256 cycleId) external {
    // Create cross-chain fee collection callbacks
    uint256 chainAFeePromise = callbackContract.then(
        nextTimeoutIds[cycleId],
        cycle.chainAFeeCollector,
        FeeCollector.collectFees.selector
    );
    
    uint256 chainBFeePromise = callbackContract.thenOn(
        cycle.chainBId,
        nextTimeoutIds[cycleId],
        cycle.chainBFeeCollector,
        FeeCollector.collectFees.selector
    );
    
    // Create PromiseAll to wait for both fee collections
    uint256[] memory feePromises = new uint256[](2);
    feePromises[0] = chainAFeePromise;
    feePromises[1] = chainBFeePromise;
    uint256 promiseAllId = promiseAllContract.create(feePromises);
    
    // Create burn callback that executes when both fees are collected
    uint256 burnCallbackId = callbackContract.then(
        promiseAllId,
        cycle.feeBurner,
        FeeBurner.burnFees.selector
    );
    
            // **CRON MAGIC**: Schedule next execution automatically
        uint256 nextTimeoutId = setTimeoutContract.create(block.timestamp + cycle.interval);
        
        // **AUTOMATIC TRIGGERING**: Create callback to automatically execute next cycle
        uint256 nextExecutionCallbackId = callbackContract.then(
            nextTimeoutId,
            address(this),
            CronScheduler.executeCycleCallback.selector
        );
        executionCallbackIds[cycleId] = nextExecutionCallbackId;
        
        nextTimeoutIds[cycleId] = nextTimeoutId;
}

/// @notice Callback wrapper for automatic cycle execution  
/// @dev This function is called automatically when timeout resolves
function executeCycleCallback(bytes memory /* data */) external returns (string memory) {
    // Find which cycle needs to be executed by checking which timeout is resolved
    for (uint256 cycleId = 1; cycleId < nextCycleId; cycleId++) {
        if (!cycles[cycleId].active) continue;
        
        uint256 timeoutId = nextTimeoutIds[cycleId];
        if (timeoutId > 0 && 
            promiseContract.status(timeoutId) == Promise.PromiseStatus.Resolved &&
            (cycles[cycleId].lastExecution == 0 || 
             block.timestamp >= cycles[cycleId].lastExecution + cycles[cycleId].interval)) {
            // This timeout resolved and cycle is ready
            this.executeCycle(cycleId);
            return "Cycle executed automatically";
        }
    }
    return "No cycles ready for execution";
}

// Time passes and cycle triggers automatically
vm.warp(block.timestamp + 3700);

// Resolve the trigger timeout (this will automatically execute the cycle)
uint256 triggerTimeoutId = cronScheduler.getNextTimeoutId(cycleId);
setTimeoutA.resolve(triggerTimeoutId);

// Resolve the automatic cycle execution callback
uint256 executionCallbackId = cronScheduler.getExecutionCallbackId(cycleId);
callbackA.resolve(executionCallbackId);

// Share timeout to Chain B so cross-chain callbacks can execute
promiseA.shareResolvedPromise(chainBId, triggerTimeoutId);
relayAllMessages();

// Fee collection callbacks become resolvable
uint256 chainAFeePromise = cronScheduler.getLastChainAFeePromise(cycleId);
uint256 chainBFeePromise = cronScheduler.getLastChainBFeePromise(cycleId);

// Execute fee collections
callbackA.resolve(chainAFeePromise);  // Collects Chain A fees
callbackB.resolve(chainBFeePromise);  // Collects Chain B fees

// Share Chain B results back to Chain A for aggregation
promiseB.shareResolvedPromise(chainAId, chainBFeePromise);
relayAllMessages();

// PromiseAll becomes resolvable when both fee collections complete
uint256 promiseAllId = cronScheduler.getLastPromiseAllId(cycleId);
promiseAllA.resolve(promiseAllId);  // Aggregates [1000 ETH, 500 ETH]

// Burn callback becomes resolvable when PromiseAll completes
uint256 burnCallbackId = cronScheduler.getLastBurnCallbackId(cycleId);
callbackA.resolve(burnCallbackId);  // Burns total 1500 ETH

// Verify the complete workflow succeeded
assertTrue(feeCollectorA.wasCollected(), "Chain A fees collected");
assertTrue(feeCollectorB.wasCollected(), "Chain B fees collected");
assertTrue(feeBurner.wasBurned(), "Fees burned");
assertEq(feeBurner.totalBurned(), 1500 ether, "Total burned: 1500 ETH");

// Verify next cycle is automatically scheduled
uint256 nextTimeoutId = cronScheduler.getNextTimeoutId(cycleId);
assertTrue(nextTimeoutId > 0, "Next timeout scheduled");