package host

import (
	"context"
	"errors"
	"github.com/carlosframework/platform/internal/activator"
	"github.com/carlosframework/platform/internal/hostwrite"
	"github.com/carlosframework/platform/internal/schedule"
	"testing"
)

func TestClaimWiringOffConstructsNothing(t *testing.T) {
	reads := 0
	w, err := newClaimWiring(context.Background(), func(string) string { reads++; return " " }, func(context.Context) (ClaimProviders, error) {
		t.Fatal("provider construction flag-off")
		return ClaimProviders{}, nil
	})
	if err != nil || reads != 1 {
		t.Fatal(err, reads)
	}
	cfg := activator.Config{}
	runner := schedule.Runner{}
	converger := schedule.Converger{}
	if err := w.configure(&cfg, &runner, &converger); err != nil {
		t.Fatal(err)
	}
	if cfg.HostWrites.Enabled || runner.HostWrites.Enabled || converger.HostWrites.Enabled {
		t.Fatal("flag off changed")
	}
	if err := w.startRegional(context.Background(), nil, nil); err != nil {
		t.Fatal(err)
	}
	if w.joined != nil {
		t.Fatal("worker flag off")
	}
}
func TestClaimWiringOnMissingProviderRefuses(t *testing.T) {
	w, err := newClaimWiring(context.Background(), func(string) string { return "0" }, nil)
	if !w.Writes.Enabled || !errors.Is(err, hostwrite.ErrUnavailable) {
		t.Fatal(w, err)
	}
	if err := w.configure(&activator.Config{}, &schedule.Runner{}, &schedule.Converger{}); err == nil {
		t.Fatal("missing provider configured")
	}
}

type testRegionalLoop struct{ started chan struct{} }

func (r testRegionalLoop) Loop(ctx context.Context, _ <-chan struct{}, _ func(error)) error {
	close(r.started)
	<-ctx.Done()
	return ctx.Err()
}

var _ RegionalLoop = testRegionalLoop{}

func TestClaimWiringRegionalContractBeforeTask10(t *testing.T) {
	loop := testRegionalLoop{started: make(chan struct{})}
	w := &ClaimWiring{Writes: hostwrite.Config{Enabled: true}, Providers: ClaimProviders{Regional: loop}}
	if err := w.startRegional(t.Context(), nil, nil); err != nil {
		t.Fatal(err)
	}
	<-loop.started
	if err := w.close(t.Context()); err != nil {
		t.Fatal(err)
	}
}