package attesto

import (
	_ "embed"
	"encoding/json"
	"errors"
	"fmt"
	"sync"
)

// [P1.10] Trimmed parity vectors vendored into the package; regenerated from
// golden-vectors/sdk-parity (do not hand-edit).
//
//go:embed selftest_vectors.json
var selftestVectors []byte

// ErrSelfTest wraps a failed vendored parity self-test: this install's hashing
// diverges from the pinned cross-language vectors (corrupted package or broken
// runtime). The SDK fails closed rather than produce wrong evidence.
var ErrSelfTest = errors.New("attesto self-test failed")

var (
	selftestOnce sync.Once
	selftestErr  error
)

func runSelfTest(raw []byte) error {
	var vectors struct {
		Commitment struct {
			Payload              map[string]any `json:"payload"`
			CanonicalPayloadHash string         `json:"canonical_payload_hash"`
		} `json:"commitment"`
		Receipt struct {
			Payload     map[string]any `json:"payload"`
			ReceiptHash string         `json:"receipt_hash"`
		} `json:"receipt"`
		Inclusion struct {
			LeafHash string          `json:"leaf_hash"`
			Proof    []InclusionStep `json:"proof"`
			RootHash string          `json:"root_hash"`
		} `json:"inclusion"`
	}
	if err := json.Unmarshal(raw, &vectors); err != nil {
		return fmt.Errorf("%w: vendored vectors unreadable: %v", ErrSelfTest, err)
	}
	canonical, err := CanonicalJSON(vectors.Commitment.Payload)
	if err != nil {
		return fmt.Errorf("%w: %v", ErrSelfTest, err)
	}
	if SHA256Hex(canonical) != vectors.Commitment.CanonicalPayloadHash {
		return fmt.Errorf("%w: commitment hash diverged from vendored vector", ErrSelfTest)
	}
	receiptHash, err := DomainHashHex(ProofstreamDomains["receipt"], vectors.Receipt.Payload)
	if err != nil {
		return fmt.Errorf("%w: %v", ErrSelfTest, err)
	}
	if receiptHash != vectors.Receipt.ReceiptHash {
		return fmt.Errorf("%w: receipt domain-hash diverged from vendored vector", ErrSelfTest)
	}
	ok, err := VerifyInclusionProof(
		vectors.Inclusion.LeafHash, vectors.Inclusion.Proof, vectors.Inclusion.RootHash)
	if err != nil || !ok {
		return fmt.Errorf("%w: inclusion fold diverged from vendored vector", ErrSelfTest)
	}
	return nil
}

// EnsureSelfTest runs the vendored parity self-test once per process (cached).
func EnsureSelfTest() error {
	selftestOnce.Do(func() { selftestErr = runSelfTest(selftestVectors) })
	return selftestErr
}