<?php
/**
 * Stable identifiers and idempotency helpers for local Evidence Memory.
 */

if (!defined('ABSPATH')) {
    exit;
}

final class AIFQ_SR_Memory_Identity {
    private static ?string $request_id = null;

    public static function uuid(): string {
        if (function_exists('wp_generate_uuid4')) {
            return (string) wp_generate_uuid4();
        }

        try {
            $bytes = random_bytes(16);
            $bytes[6] = chr((ord($bytes[6]) & 0x0f) | 0x40);
            $bytes[8] = chr((ord($bytes[8]) & 0x3f) | 0x80);
            $hex = bin2hex($bytes);
            return sprintf(
                '%s-%s-%s-%s-%s',
                substr($hex, 0, 8),
                substr($hex, 8, 4),
                substr($hex, 12, 4),
                substr($hex, 16, 4),
                substr($hex, 20, 12)
            );
        } catch (Throwable $e) {
            return hash('sha256', uniqid('aifq-sr-', true) . microtime(true));
        }
    }

    public static function request_id(): string {
        if (self::$request_id === null) {
            self::$request_id = self::uuid();
        }

        return self::$request_id;
    }

    /**
     * Idempotency for one concrete observed occurrence.
     *
     * The caller owns occurrence semantics. The production recorder reuses an
     * occurrence token for indistinguishable repeated delivery on one entity
     * stream, but advances the token after a different transition so legitimate
     * oscillations are not collapsed. Different requests naturally receive a
     * different request-scoped token.
     */
    public static function observed_idempotency_key(array $record, string $occurrence_token): string {
        return hash('sha256', implode('|', [
            'observed',
            self::bounded($occurrence_token, 128),
            self::bounded((string) ($record['source'] ?? ''), 64),
            self::bounded((string) ($record['event_type'] ?? ''), 64),
            self::bounded((string) ($record['entity_type'] ?? ''), 32),
            self::bounded((string) ($record['entity_id'] ?? ''), 255),
            self::canonical_json($record['previous_state'] ?? null),
            self::canonical_json($record['new_state'] ?? null),
        ]));
    }

    /**
     * Idempotency for one Detected transition from a specific trusted anchor.
     *
     * The current snapshot UUID is deliberately NOT part of this key. A retry
     * after an interrupted review rebuilds a fresh current snapshot UUID, but
     * it is still the same transition from the same previous anchor and must
     * not create duplicate Evidence. Once the anchor advances, a later similar
     * transition naturally receives a different key.
     */
    public static function detected_idempotency_key(
        string $previous_snapshot_id,
        array $record
    ): string {
        return hash('sha256', implode('|', [
            'detected',
            self::bounded($previous_snapshot_id, 128),
            self::bounded((string) ($record['event_type'] ?? ''), 64),
            self::bounded((string) ($record['entity_type'] ?? ''), 32),
            self::bounded((string) ($record['entity_id'] ?? ''), 255),
            self::canonical_json($record['previous_state'] ?? null),
            self::canonical_json($record['new_state'] ?? null),
        ]));
    }

    public static function canonical_json($value): string {
        $value = self::canonicalize($value);
        if (function_exists('wp_json_encode')) {
            $encoded = wp_json_encode($value, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
        } else {
            $encoded = json_encode($value, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
        }

        return is_string($encoded) ? $encoded : 'null';
    }

    private static function canonicalize($value) {
        if (!is_array($value)) {
            return $value;
        }

        if (self::is_list_array($value)) {
            return array_map([self::class, 'canonicalize'], $value);
        }

        ksort($value, SORT_STRING);
        foreach ($value as $key => $item) {
            $value[$key] = self::canonicalize($item);
        }
        return $value;
    }


    private static function is_list_array(array $value): bool {
        $expected = 0;
        foreach ($value as $key => $_item) {
            if ($key !== $expected) {
                return false;
            }
            $expected++;
        }
        return true;
    }

    private static function bounded(string $value, int $length): string {
        return substr($value, 0, $length);
    }
}