package proxy

import (
	"context"
	"encoding/json"
	"io/ioutil"
	"testing"

	"forge.cadoles.com/Cadoles/emissary/internal/datastore/memory"
	"forge.cadoles.com/Cadoles/emissary/internal/spec"
	"github.com/pkg/errors"
)

type validatorTestCase struct {
	Name       string
	Source     string
	ShouldFail bool
}

var validatorTestCases = []validatorTestCase{
	{
		Name:       "SpecOK",
		Source:     "testdata/spec-ok.json",
		ShouldFail: false,
	},
	{
		Name:       "SpecMissingProp",
		Source:     "testdata/spec-missing-prop.json",
		ShouldFail: true,
	},
	{
		Name:       "SpecAdditionalProp",
		Source:     "testdata/spec-additional-prop.json",
		ShouldFail: true,
	},
}

func TestValidator(t *testing.T) {
	t.Parallel()

	ctx := context.Background()

	repo := memory.NewSpecDefinitionRepository()
	if _, err := repo.Upsert(ctx, Name, Version, schema); err != nil {
		t.Fatalf("+%v", errors.WithStack(err))
	}

	validator := spec.NewValidator(repo)

	for _, tc := range validatorTestCases {
		func(tc validatorTestCase) {
			t.Run(tc.Name, func(t *testing.T) {
				t.Parallel()

				rawSpec, err := ioutil.ReadFile(tc.Source)
				if err != nil {
					t.Fatalf("+%v", errors.WithStack(err))
				}

				var spec spec.RawSpec

				if err := json.Unmarshal(rawSpec, &spec); err != nil {
					t.Fatalf("+%v", errors.WithStack(err))
				}

				ctx := context.Background()

				err = validator.Validate(ctx, &spec)

				if !tc.ShouldFail && err != nil {
					t.Errorf("+%v", errors.WithStack(err))
				}

				if tc.ShouldFail && err == nil {
					t.Error("validation should have failed")
				}
			})
		}(tc)
	}
}