package responseschema

import (
	"bytes"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"testing"
)

const (
	expectedCorrectionSetSHA256        = "b86a2dde38d7f440d26470fa8830167512bb0aa1b35e5fee5547057be583c388"
	expectedValidatorDecisionSetSHA256 = "2fe90d450e2595b57885aba91c8cc5cedf783dd36758ab430309e3eace401f54"
)

func TestLookupKnownSchemas(t *testing.T) {
	correction, ok := Lookup(CorrectionSetKey)
	if !ok {
		t.Fatalf("expected correction-set schema to be registered")
	}
	if correction.ID != correctionSetSchemaID {
		t.Fatalf("unexpected correction-set schema id %q", correction.ID)
	}
	if correction.Version != schemaVersionV1 {
		t.Fatalf("unexpected correction-set schema version %q", correction.Version)
	}
	if correction.Name != "audita_correction_set_v1" {
		t.Fatalf("unexpected correction-set schema name %q", correction.Name)
	}

	validation, ok := Lookup(ValidatorDecisionSetKey)
	if !ok {
		t.Fatalf("expected validator-decision schema to be registered")
	}
	if validation.ID != validatorDecisionSchemaID {
		t.Fatalf("unexpected validator-decision schema id %q", validation.ID)
	}
	if validation.Version != schemaVersionV1 {
		t.Fatalf("unexpected validator-decision schema version %q", validation.Version)
	}
	if validation.Name != "audita_validator_decision_set_v1" {
		t.Fatalf("unexpected validator-decision schema name %q", validation.Name)
	}
}

func TestLookupUnknownSchema(t *testing.T) {
	if _, ok := Lookup(Key("missing")); ok {
		t.Fatalf("expected unknown schema lookup to fail")
	}
}

func TestRegisteredSchemasLoadReadableEmbeddedJSON(t *testing.T) {
	for _, schema := range Registered() {
		if len(schema.JSONSchema) == 0 {
			t.Fatalf("expected non-empty JSON schema for %q", schema.ID)
		}
		if !json.Valid(schema.JSONSchema) {
			t.Fatalf("expected valid JSON schema for %q", schema.ID)
		}
		if !bytes.Contains(schema.JSONSchema, []byte("\n  ")) {
			t.Fatalf("expected readable formatted JSON schema for %q", schema.ID)
		}
	}
}

func TestSchemaHashesMatchRegisteredJSON(t *testing.T) {
	expectedByKey := map[Key]string{
		CorrectionSetKey:        expectedCorrectionSetSHA256,
		ValidatorDecisionSetKey: expectedValidatorDecisionSetSHA256,
	}
	for key, expectedHash := range expectedByKey {
		schema, ok := Lookup(key)
		if !ok {
			t.Fatalf("missing schema %q", key)
		}
		sum := sha256.Sum256(schema.JSONSchema)
		expected := hex.EncodeToString(sum[:])
		if schema.SHA256 != expectedHash {
			t.Fatalf("unexpected stable hash for %q: got %q want %q", key, schema.SHA256, expectedHash)
		}
		if schema.SHA256 != expected {
			t.Fatalf("unexpected hash for %q: got %q want %q", key, schema.SHA256, expected)
		}
	}
}

func TestLookupReturnsSchemaCopy(t *testing.T) {
	schema, ok := Lookup(CorrectionSetKey)
	if !ok {
		t.Fatalf("missing correction-set schema")
	}
	if len(schema.JSONSchema) == 0 {
		t.Fatalf("expected non-empty schema payload")
	}
	schema.JSONSchema[0] = 'x'

	again, ok := Lookup(CorrectionSetKey)
	if !ok {
		t.Fatalf("missing correction-set schema on second lookup")
	}
	if len(again.JSONSchema) == 0 {
		t.Fatalf("unexpected empty schema payload")
	}
	if again.JSONSchema[0] != '{' {
		t.Fatalf("expected lookup to return independent schema copy")
	}
}

func TestDiagnosticsMapIncludesStableSchemaMetadataShapeForAllSchemas(t *testing.T) {
	registered := Registered()
	if len(registered) == 0 {
		t.Fatalf("expected registered response schemas")
	}

	for _, schema := range registered {
		metadataMap := schema.DiagnosticsMap()
		if metadataMap["id"] != schema.ID ||
			metadataMap["version"] != schema.Version ||
			metadataMap["name"] != schema.Name ||
			metadataMap["sha256"] != schema.SHA256 {
			t.Fatalf("unexpected diagnostics metadata map for %q: %+v", schema.ID, metadataMap)
		}
	}
}