package activator

import (
	"context"
	"errors"
	"sync/atomic"
	"testing"
	"time"

	"github.com/carlosframework/platform/internal/registry"
)

// Final review F4 (activator half): every GenEvent of a planned wake carries
// that wake's token and the config revision it started with, as the plan
// handed them in (WakePlan.Token, WakePlan.ConfigRev), so the scheduler can
// match an outcome to the wake that produced it and an old event can never
// clear or activate a newer wake's state. Covered: afterWake's events
// (healthy, fellback, failed, untried, a worker's settled) and the
// observer's (settled, failed, cancelled), and a replanned wake, whose
// events carry the replan's token.
func TestEveryGenEventCarriesItsWakesToken(t *testing.T) {
	const token, rev = uint64(0x5eed), "cfg-7"
	for _, tc := range []struct {
		name string
		run  func(t *testing.T) []GenEvent
	}{
		{"healthy, then settled by the observer", func(t *testing.T) []GenEvent {
			shrinkFirstWake(t, 55*time.Second, 25*time.Second, 100*time.Millisecond)
			good, next := stagedID(t, t.TempDir(), "v1"), stagedID(t, t.TempDir(), "v2")
			a, _, evs := planActivator(t, WakePlan{Boot: next, Mode: ModeOverlap, FirstWake: true, Fallback: &good, Token: token, ConfigRev: rev})
			mustServe(t, a)
			evs.wait(t, GenSettled)
			return evs.all()
		}},
		{"fell back", func(t *testing.T) []GenEvent {
			good, next := stagedID(t, t.TempDir(), "v1"), stagedID(t, t.TempDir(), "v2")
			a, _, evs := planActivator(t, WakePlan{Boot: next, Mode: ModeOverlap, FirstWake: true, Fallback: &good, Token: token, ConfigRev: rev})
			a.genHealth = failBuild("v2")
			mustServe(t, a)
			evs.wait(t, GenFellBack)
			return evs.all()
		}},
		{"failed in hold mode", func(t *testing.T) []GenEvent {
			next := stagedID(t, t.TempDir(), "v2")
			a, _, evs := planActivator(t, WakePlan{Boot: next, Mode: ModeHold, FirstWake: true, Token: token, ConfigRev: rev})
			a.genHealth = failBuild("v2")
			_, _ = a.beginRequest(context.Background(), testRoute("one.example.com"))
			evs.wait(t, GenFailed)
			return evs.all()
		}},
		{"untried under the verdict floor", func(t *testing.T) []GenEvent {
			shrinkVerdictFloor(t, time.Hour)
			good, next := stagedID(t, t.TempDir(), "v1"), stagedID(t, t.TempDir(), "v2")
			a, _, evs := planActivator(t, WakePlan{Boot: next, Mode: ModeOverlap, FirstWake: true, Fallback: &good, Token: token, ConfigRev: rev})
			mustServe(t, a)
			evs.wait(t, GenHealthy)
			return evs.all()
		}},
		{"failed by the observer", func(t *testing.T) []GenEvent {
			shrinkFirstWake(t, 55*time.Second, 25*time.Second, 2*time.Second)
			good, next := stagedID(t, t.TempDir(), "v1"), stagedID(t, t.TempDir(), "v2")
			a, b, evs := planActivator(t, WakePlan{Boot: next, Mode: ModeOverlap, FirstWake: true, Fallback: &good, Token: token, ConfigRev: rev})
			mustServe(t, a)
			evs.wait(t, GenHealthy)
			b.procOf(b.started()[0].N).crash()
			evs.wait(t, GenFailed)
			return evs.all()
		}},
		{"cancelled by an intentional stop", func(t *testing.T) []GenEvent {
			shrinkFirstWake(t, 55*time.Second, 25*time.Second, 2*time.Second)
			good, next := stagedID(t, t.TempDir(), "v1"), stagedID(t, t.TempDir(), "v2")
			a, _, evs := planActivator(t, WakePlan{Boot: next, Mode: ModeOverlap, FirstWake: true, Fallback: &good, Token: token, ConfigRev: rev})
			mustServe(t, a)
			evs.wait(t, GenHealthy)
			a.BounceFor("one.example.com", CauseConfig)
			evs.wait(t, GenCancelled)
			return evs.all()
		}},
		{"a worker's first wake, settled at its readiness", func(t *testing.T) []GenEvent {
			shrinkFirstWake(t, 55*time.Second, 25*time.Second, 100*time.Millisecond)
			a, _, _, _, _ := stagedActivator(t)
			a.gens = true
			evs := &genLog{}
			a.OnGen = evs.add
			good, next := stagedID(t, t.TempDir(), "v1"), stagedID(t, t.TempDir(), "v2")
			a.Planner = func(context.Context, registry.Route) WakePlan {
				return WakePlan{Boot: next, Mode: ModeOverlap, FirstWake: true, Fallback: &good, Token: token, ConfigRev: rev}
			}
			if err := a.WakeWorker(alwaysOnWorkerRoute("bot.x.internal")); err != nil {
				t.Fatal(err)
			}
			evs.wait(t, GenSettled)
			return evs.all()
		}},
		{"replanned at the exec: the replan's token", func(t *testing.T) []GenEvent {
			good, next := stagedID(t, t.TempDir(), "v1"), stagedID(t, t.TempDir(), "v2")
			a, _, evs := planActivator(t, WakePlan{})
			var plans atomic.Int32
			held := func(build string) error {
				if build == "v2" {
					return errors.New("v2 failed on a sibling")
				}
				return nil
			}
			a.Planner = func(context.Context, registry.Route) WakePlan {
				if plans.Add(1) == 1 {
					return WakePlan{Boot: next, Mode: ModeOverlap, FirstWake: true, Fallback: &good, Check: held, Token: token - 1, ConfigRev: "cfg-6"}
				}
				return WakePlan{Boot: good, Mode: ModeOverlap, Check: held, Token: token, ConfigRev: rev}
			}
			mustServe(t, a)
			evs.wait(t, GenHealthy)
			// The replaced plan's own cancellation (Task 5) carries its own
			// token; every other event is the replan's.
			var out []GenEvent
			for _, ev := range evs.all() {
				if ev.Token == token-1 {
					if ev.Kind != GenCancelled || ev.Executed || ev.ConfigRev != "cfg-6" {
						t.Fatalf("replaced plan's event %+v: want GenCancelled, not executed, with its own token and config", ev)
					}
					continue
				}
				out = append(out, ev)
			}
			if len(out) == len(evs.all()) {
				t.Fatalf("events %+v: the replaced plan was not cancelled", evs.all())
			}
			return out
		}},
	} {
		t.Run(tc.name, func(t *testing.T) {
			evs := tc.run(t)
			if len(evs) == 0 {
				t.Fatal("no events")
			}
			for _, ev := range evs {
				if ev.Token != token || ev.ConfigRev != rev {
					t.Fatalf("%s event carries token %#x, config %q; want the wake's %#x, %q (all: %+v)", ev.Kind, ev.Token, ev.ConfigRev, token, rev, evs)
				}
			}
		})
	}
}

func mustServe(t *testing.T, a *Service) {
	t.Helper()
	done, err := a.beginRequest(context.Background(), testRoute("one.example.com"))
	if err != nil {
		t.Fatal(err)
	}
	done()
}

func failBuild(build string) func(context.Context, Gen) error {
	return func(_ context.Context, g Gen) error {
		if g.Build == build {
			return errors.New("GET / answered 500")
		}
		return nil
	}
}

func (l *genLog) all() []GenEvent {
	l.mu.Lock()
	defer l.mu.Unlock()
	return append([]GenEvent(nil), l.evs...)
}