package park

import (
	"context"
	"errors"
	"net/url"
	"reflect"
	"strings"
	"testing"
	"time"

	"github.com/carlosframework/platform/internal/hostclaim"
	"github.com/carlosframework/platform/internal/lease"
)

func movesFixture(t *testing.T, op string) *fixture {
	t.Helper()
	f := newFixture(t)
	obs, err := hostclaim.Read(t.Context(), f.e.Claims, f.w.Host)
	if err != nil {
		t.Fatal(err)
	}
	f.ob.Park.Location = "moves/" + f.w.Host
	if op != "" {
		f.ob.Park.Location += "/" + op
	}
	_, err = hostclaim.Update(t.Context(), f.e.Claims, obs, func(c *hostclaim.Claim) error {
		c.Op = hostclaim.Op{Kind: hostclaim.KindServing, Exec: "box"}
		c.Holder.Generation = "live"
		c.Obligations = []hostclaim.Obligation{f.ob}
		return nil
	})
	if err != nil {
		t.Fatal(err)
	}
	f.e.View = func(_ context.Context, o hostclaim.Observed) (View, error) {
		return View{ClaimETag: o.ETag, Region: "ie", AuthoritativeRegion: "ie", MarkerKnown: true, MarkerGeneration: "unrelated", GenerationOf: func(Ref) (string, bool) { return "live", true }}, nil
	}
	return f
}

func TestMovesScopeParksExactPrefixAndResumes(t *testing.T) {
	for _, op := range []string{"move-1", strings.Repeat("b", 64), ""} {
		t.Run("op="+op, func(t *testing.T) {
			f := movesFixture(t, op)
			p := f.ob.Park.Location + "/"
			expected := map[Ref]string{}
			for _, name := range []string{"replica/0000/data", "seal.json"} {
				for _, body := range []string{"old", "new"} {
					id := f.b.Put("data", p+name, []byte(body))
					expected[Ref{p + name, id}] = body
				}
			}
			f.b.BareDelete("data", p+"replica/0000/data")
			lock := Ref{p + "lock.json", f.b.Put("data", p+"lock.json", []byte("lease"))}
			untouched := map[Ref]string{lock: "lease"}
			keys := []string{"instances/" + f.w.Host + "/0000/data", "instances/" + f.w.Host + "/" + f.ob.Park.Incarnation + "/live/data", "moves/other.example/move-1/data", "moves/" + f.w.Host + "-other/move-1/data"}
			if op != "" {
				keys = append(keys, f.ob.Park.Location+"-sibling/data", "moves/"+f.w.Host+"/sibling/data")
			}
			for _, key := range keys {
				untouched[Ref{key, f.b.Put("data", key, []byte("untouched"))}] = "untouched"
			}
			listings := 0
			f.b.FailOn = func(action, key string) error {
				if action == "list" && !strings.HasPrefix(key, "parked/") {
					listings++
					if key != p {
						t.Errorf("listing %q, want only %q", key, p)
						return ErrUnsafe
					}
				}
				return nil
			}
			f.e.After = func(step string) error {
				if step == "delete" {
					return ErrPending
				}
				return nil
			}
			if err := f.e.Run(t.Context(), f.w); !errors.Is(err, ErrPending) {
				t.Fatalf("interrupted retirement: %v", err)
			}
			f.e.After = nil
			checkListing := f.b.FailOn
			f.b.FailOn = func(action, key string) error {
				if action == "copy" {
					t.Error("manifest retry copied a source")
					return ErrUnsafe
				}
				return checkListing(action, key)
			}
			if err := f.e.Run(t.Context(), f.w); err != nil {
				t.Fatalf("resumed retirement: %v", err)
			}
			if listings != 2 || f.held.released != 1 {
				t.Fatalf("listings=%d releases=%d", listings, f.held.released)
			}
			f.done(t)
			m, err := f.e.manifest(t.Context(), f.w, f.ob)
			if err != nil || m == nil || len(m.Archive) != len(expected) || len(m.Delete) != len(expected)+1 {
				t.Fatalf("manifest: %+v %v", m, err)
			}
			for _, copied := range m.Archive {
				body, ok := expected[ref(copied.Source)]
				wantKey := "parked/" + f.ob.Park.Incarnation + "/" + f.w.Host + "/" + f.ob.Retirement + "/moves/" + strings.TrimPrefix(copied.Source.Key, p) + "@" + url.QueryEscape(copied.Source.VersionID)
				if !ok || copied.Destination.Key != wantKey {
					t.Fatalf("unexpected archive copy: %+v", copied)
				}
				got, err := f.b.GetVersion(t.Context(), "data", copied.Destination.Key, copied.Destination.VersionID)
				if err != nil || string(got) != body {
					t.Fatalf("archive body=%q, want %q: %v", got, body, err)
				}
			}
			for _, source := range m.Delete {
				if _, err := f.b.GetVersion(t.Context(), "data", source.Key, source.VersionID); !errors.Is(err, lease.ErrMirrorNotFound) {
					t.Fatalf("source remains: %+v %v", source, err)
				}
			}
			for r, body := range untouched {
				got, err := f.b.GetVersion(t.Context(), "data", r.Key, r.VersionID)
				if err != nil || string(got) != body {
					t.Fatalf("unrelated version changed: %+v %q %v", r, got, err)
				}
			}
		})
	}
}

func TestMovesScopeUsesPersistedEvidenceHorizon(t *testing.T) {
	for _, op := range []string{"move-1", ""} {
		for _, offset := range []time.Duration{-time.Minute, 0, time.Hour} {
			t.Run("op="+op+"/offset="+offset.String(), func(t *testing.T) {
				f := movesFixture(t, op)
				f.b.Put("data", f.ob.Park.Location+"/staging/data", []byte("staged"))
				deadline := f.ob.Park.EvidenceAt.Add(SignatureAge + f.ob.Park.RequestLimit)
				f.now = deadline.Add(offset)
				f.e.After = func(step string) error {
					if step == "verify" {
						f.now = deadline.Add(2 * time.Hour)
					}
					return nil
				}
				err := f.e.Run(t.Context(), f.w)
				if offset > 0 {
					if err != nil {
						t.Fatalf("delayed cleanup did not acknowledge immediately: %v", err)
					}
				} else {
					if !errors.Is(err, ErrPending) {
						t.Fatalf("early verification: %v", err)
					}
					obs, err := hostclaim.Read(t.Context(), f.e.Claims, f.w.Host)
					if err != nil {
						t.Fatal(err)
					}
					if len(obs.Claim.Obligations) != 1 || len(obs.Claim.QuietAfter) != 0 || f.held.released != 0 {
						t.Fatal("acknowledged before a listing after the horizon")
					}
					if !reflect.DeepEqual(obs.Claim.Obligations[0].Park, f.ob.Park) {
						t.Fatal("persisted evidence changed")
					}
					f.e.After = nil
					if err := f.e.Run(t.Context(), f.w); err != nil {
						t.Fatalf("later verification: %v", err)
					}
				}
				f.done(t)
			})
		}
	}
}

func TestBindMovesScope(t *testing.T) {
	f := newFixture(t)
	obs, err := hostclaim.Read(t.Context(), f.e.Claims, f.w.Host)
	if err != nil {
		t.Fatal(err)
	}
	_, err = hostclaim.Update(t.Context(), f.e.Claims, obs, func(c *hostclaim.Claim) error {
		c.Obligations[0].Park = nil
		return nil
	})
	if err != nil {
		t.Fatal(err)
	}
	p := *f.ob.Park
	p.Location = "moves/" + f.w.Host + "/move-1"
	authorized := false
	f.e.Authorize = func(_ context.Context, _ hostclaim.Observed, o hostclaim.Obligation) error {
		authorized = reflect.DeepEqual(o.Park, &p)
		return nil
	}
	if err := f.e.Bind(t.Context(), f.w, p); err != nil {
		t.Fatal(err)
	}
	obs, err = hostclaim.Read(t.Context(), f.e.Claims, f.w.Host)
	if err != nil {
		t.Fatal(err)
	}
	if !authorized || !reflect.DeepEqual(obs.Claim.Obligations[0].Park, &p) {
		t.Fatal("staging scope not authorized and persisted")
	}
}