package console

import (
	"context"
	"encoding/json"
	"errors"
	"io"
	"strings"
	"testing"

	"github.com/carlosframework/platform/internal/hostclaim"
	"github.com/carlosframework/platform/internal/hostops"
	"github.com/carlosframework/platform/internal/release"
)

type plan15ConsoleStream struct {
	release.Store
	read, closed int
}

func (s *plan15ConsoleStream) Get(ctx context.Context, key string) ([]byte, string, error) {
	if strings.Contains(key, "control/host-origins/") {
		panic("console wrapper buffered origin")
	}
	return s.Store.Get(ctx, key)
}
func (s *plan15ConsoleStream) Open(context.Context, string) (io.ReadCloser, string, error) {
	return plan15ConsoleReader{s, strings.NewReader(strings.Repeat("x", 8192))}, "", nil
}

type plan15ConsoleReader struct {
	s *plan15ConsoleStream
	r io.Reader
}

func (r plan15ConsoleReader) Read(b []byte) (int, error) {
	n, e := r.r.Read(b)
	r.s.read += n
	return n, e
}
func (r plan15ConsoleReader) Close() error { r.s.closed++; return nil }

type plan15ConsoleGetOnly struct{ release.Store }

func TestPlan15ConsoleStreamingCompositions(t *testing.T) {
	for _, stream := range []bool{false, true} {
		t.Run(map[bool]string{false: "get-only", true: "streaming"}[stream], func(t *testing.T) {
			raw := release.NewDirStore(t.TempDir())
			logical := release.NewPrefixStore(raw, "deployment")
			claim := &hostclaim.Claim{V: 2, Host: "x.example", Gen: 1, Origins: &hostclaim.OriginHead{Digest: strings.Repeat("a", 64), Count: 1}}
			body, _ := json.Marshal(claim)
			key, _ := hostclaim.Key(claim.Host)
			tag, err := logical.Put(t.Context(), key, body, "")
			if err != nil {
				t.Fatal(err)
			}
			obs := hostclaim.Observed{Host: claim.Host, Claim: claim, ETag: tag}
			counter := &plan15ConsoleStream{Store: raw}
			var s release.Store = counter
			if !stream {
				s = plan15ConsoleGetOnly{s}
			}
			s = release.NewPrefixStore(s, "deployment")
			s, err = hostops.NewConditionalRecordStore(s, make([]byte, 32))
			if err != nil {
				t.Fatal(err)
			}
			s, err = hostops.NewMutationBoundary(true, s, func(context.Context, hostops.MutationTarget) error { return nil })
			if err != nil {
				t.Fatal(err)
			}
			s = claimAliasStore{data: claimEffectStore{data: s}}
			if got, err := hostclaim.AdmittedOrigin(t.Context(), s, obs, strings.Repeat("b", 64), "instances/x.example", "ie", "real"); got || !errors.Is(err, hostclaim.ErrMalformed) {
				t.Fatalf("proof %v %v", got, err)
			}
			if stream && (counter.read != 4097 || counter.closed != 1) {
				t.Fatalf("read=%d closed=%d", counter.read, counter.closed)
			}
			if !stream && (counter.read != 0 || counter.closed != 0) {
				t.Fatal("opened get-only store")
			}
		})
	}
}