package console

import (
	"context"
	"errors"
	"io"
	"net/http"
	"testing"
	"time"

	"github.com/carlosframework/platform/internal/appconfig"
	"github.com/carlosframework/platform/internal/hostops"
	"github.com/carlosframework/platform/internal/objstore"
	"github.com/carlosframework/platform/internal/release"
)

type callbackBrokenBody struct{}

func (callbackBrokenBody) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF }
func (callbackBrokenBody) Close() error             { return nil }

func TestClaimScanCallbackContentionAndSettlement(t *testing.T) {
	for _, mode := range []string{"success", "transport failure", "accepted broken body"} {
		t.Run(mode, func(t *testing.T) {
			w := newScanClaimWorld(t)
			rec, _, err := objstore.Get(context.Background(), w.cx.rel, "bab", "titogo")
			if err != nil {
				t.Fatal(err)
			}
			job := scanDeliveryJob{ref: objstore.AppRef{Account: "bab", App: "titogo"}, gen: rec.Scanning.WebhookGen}
			calls := 0
			p := &scanDeliveryPool{s: w.cx.srv, ctx: context.Background(), client: &http.Client{Transport: callbackRoundTripper(func(r *http.Request) (*http.Response, error) {
				calls++
				competingCalled := false
				err := w.cx.srv.claimAppMutation(context.Background(), &Account{Sqid: "bab"}, "titogo", "competing-callback", func(context.Context) error { competingCalled = true; return nil })
				if !errors.Is(err, hostops.ErrPending) || competingCalled {
					t.Errorf("callback did not fence competing mutation: %v called=%v", err, competingCalled)
				}
				if mode == "transport failure" {
					return nil, io.ErrUnexpectedEOF
				}
				res := callbackResponse(http.StatusOK)
				if mode == "accepted broken body" {
					res.Body = callbackBrokenBody{}
				}
				return res, nil
			})}}
			err = w.cx.srv.claimAppMutation(context.Background(), &Account{Sqid: "bab"}, "titogo", "busy-before-callback", func(context.Context) error {
				retry, err := p.attempt(job, "https://titogo.bab.example/hook", []byte(`{}`))
				if !retry || !errors.Is(err, hostops.ErrPending) || calls != 0 {
					t.Errorf("busy callback retry=%v err=%v calls=%d", retry, err, calls)
				}
				return nil
			})
			if err != nil {
				t.Fatal(err)
			}
			retry, err := p.attempt(job, "https://titogo.bab.example/hook", []byte(`{}`))
			if mode == "transport failure" {
				if !retry || err == nil {
					t.Errorf("failed transport retry=%v err=%v", retry, err)
				}
			} else if retry || err != nil {
				t.Errorf("accepted callback retry=%v err=%v", retry, err)
			}
			if calls != 1 {
				t.Errorf("transport called %d times", calls)
			}
			requireOpen(t, w.admission(t), "after callback attempt")
		})
	}
}

func TestClaimScanMasterRotationSkipsBusyApp(t *testing.T) {
	w := newScanClaimWorld(t)
	w.cx.srv.cfg.CallbackSigner = callbackTestSigner(t, "review-new-master", "claim-fixture-webhook-master")
	pub, err := appconfig.ParsePublicKey(w.cx.srv.cfg.SecretsPub, "test")
	if err != nil {
		t.Fatal(err)
	}
	err = w.cx.srv.claimAppMutation(context.Background(), &Account{Sqid: "bab"}, "titogo", "busy-before-rotation", func(context.Context) error {
		remaining, changed, err := w.cx.srv.rotateWebhookBudget(context.Background(), pub)
		if err != nil || remaining != 1 || changed != 0 {
			t.Errorf("busy rotation remaining=%d changed=%d err=%v", remaining, changed, err)
		}
		return nil
	})
	if err != nil {
		t.Fatal(err)
	}
	remaining, changed, err := w.cx.srv.rotateWebhookBudget(context.Background(), pub)
	if err != nil || remaining != 0 || changed != 1 {
		t.Fatalf("resumed rotation remaining=%d changed=%d err=%v", remaining, changed, err)
	}
	requireOpen(t, w.admission(t), "after rotation")
}

func TestScanMasterRotationLeavesTrashedConfigAlone(t *testing.T) {
	fx, _, _ := rotationRaceFixture(t, "review-trash")
	fx.srv.cfg.CallbackSigner = callbackTestSigner(t, "review-new-master", testWebhookMaster)
	_, before, err := fx.rel.Get(context.Background(), appconfig.Key(fx.sqid, "titogo"))
	if err != nil {
		t.Fatal(err)
	}
	if err := release.TrashApp(context.Background(), fx.rel, fx.sqid, "titogo", "test", time.Now()); err != nil {
		t.Fatal(err)
	}
	pub, err := appconfig.ParsePublicKey(fx.srv.cfg.SecretsPub, "test")
	if err != nil {
		t.Fatal(err)
	}
	remaining, changed, err := fx.srv.rotateWebhookBudget(context.Background(), pub)
	if err != nil || remaining != 0 || changed != 0 {
		t.Errorf("trashed rotation remaining=%d changed=%d err=%v", remaining, changed, err)
	}
	_, _, err = fx.srv.convergeCallbackKey(context.Background(), pub, &Account{Sqid: fx.sqid}, "titogo")
	if !errors.Is(err, objstore.ErrQueueNotPermitted) {
		t.Errorf("direct trashed convergence err=%v", err)
	}
	_, after, err := fx.rel.Get(context.Background(), appconfig.Key(fx.sqid, "titogo"))
	if err != nil {
		t.Fatal(err)
	}
	if before != after {
		t.Error("rotation rewrote a trashed app's config")
	}
}

func TestScanRegrantInvalidatesRevokedCallbackSecret(t *testing.T) {
	fx, token, private := rotationRaceFixture(t, "review-regrant")
	old := callbackSecret(t, fx, private, "titogo")
	status, body := postJSON(t, scanURL(fx, "titogo")+"/revoke", map[string]any{}, token)
	if status != http.StatusOK {
		t.Fatalf("revoke %d %v", status, body)
	}
	status, body = postJSON(t, scanURL(fx, "titogo")+"/grant", map[string]any{}, token)
	if status != http.StatusOK {
		t.Fatalf("regrant %d %v", status, body)
	}
	if got := callbackSecret(t, fx, private, "titogo"); got == old {
		t.Fatal("regrant reactivated the revoked callback secret")
	}
}

func TestScanMasterRotationRechecksTrashUnderPermit(t *testing.T) {
	fx, _, _ := rotationRaceFixture(t, "review-trash-race")
	fx.srv.cfg.CallbackSigner = callbackTestSigner(t, "review-new-master", testWebhookMaster)
	_, before, err := fx.rel.Get(context.Background(), appconfig.Key(fx.sqid, "titogo"))
	if err != nil {
		t.Fatal(err)
	}
	runner := &racingRunner{Store: fx.rel, action: "scan-webhook-rotate", race: func(ctx context.Context) {
		if err := release.TrashApp(ctx, fx.rel, fx.sqid, "titogo", "test", time.Now()); err != nil {
			t.Fatal(err)
		}
	}}
	fx.srv.cfg.Releases = runner
	pub, err := appconfig.ParsePublicKey(fx.srv.cfg.SecretsPub, "test")
	if err != nil {
		t.Fatal(err)
	}
	remaining, changed, err := fx.srv.rotateWebhookBudget(context.Background(), pub)
	if err != nil || remaining != 0 || changed != 0 || !runner.raced.Load() || runner.puts.Load() != 0 {
		t.Errorf("trash race remaining=%d changed=%d raced=%v puts=%d err=%v", remaining, changed, runner.raced.Load(), runner.puts.Load(), err)
	}
	_, after, err := fx.rel.Get(context.Background(), appconfig.Key(fx.sqid, "titogo"))
	if err != nil {
		t.Fatal(err)
	}
	if before != after {
		t.Error("rotation rewrote config after app was trashed before the permit")
	}
}