package user

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"reflect"
	"strings"
	"testing"

	"git.golem15.com/golem15/sm-user-plugin/classes"
	"git.golem15.com/golem15/sm-user-plugin/controllers"
	"git.golem15.com/golem15/summercms/modules/backpack"
)

// fakeProviderSource is a social-login plugin's provider source.
type fakeProviderSource struct {
	enabled []classes.OAuthProvider
	known   []string
}

func (f fakeProviderSource) EnabledOAuthProviders(context.Context) []classes.OAuthProvider {
	return f.enabled
}

func (f fakeProviderSource) KnownOAuthProviders() []string { return f.known }

// TestOAuthProvidersSourceSmoke checks that oauth-providers keeps the empty
// body without a published source and lists the source's enabled providers,
// looked up per request, once one is published.
func TestOAuthProvidersSourceSmoke(t *testing.T) {
	app := backpack.New(sessionConfig(t))
	h := controllers.OAuthProviders(app)
	get := func() *httptest.ResponseRecorder {
		req := httptest.NewRequest(http.MethodGet, "/_user/api/v1/oauth-providers", nil)
		rec := httptest.NewRecorder()
		h(rec, req)
		return rec
	}

	empty := get()
	if empty.Code != http.StatusOK {
		t.Fatalf("status without a source = %d", empty.Code)
	}
	// The bytes the handler answered before sources existed (wire encodes
	// map keys sorted; the PHP recording has the same JSON value).
	if got := strings.TrimRight(empty.Body.String(), "\n"); got != `{"providers":[],"success":true}` {
		t.Fatalf("body without a source = %s", got)
	}

	src := fakeProviderSource{
		enabled: []classes.OAuthProvider{{Name: "google", Label: "Google"}},
		known:   []string{"google", "facebook"},
	}
	if err := app.Publish[classes.OAuthProviderSource](src); err != nil {
		t.Fatal(err)
	}
	rec := get()
	if rec.Code != http.StatusOK {
		t.Fatalf("status with a source = %d", rec.Code)
	}
	if cc := rec.Header().Get("Cache-Control"); cc != "no-cache, private" {
		t.Fatalf("Cache-Control = %q", cc)
	}
	var body struct {
		Success   bool                    `json:"success"`
		Providers []classes.OAuthProvider `json:"providers"`
	}
	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
		t.Fatalf("decode %s: %v", rec.Body.String(), err)
	}
	if !body.Success || !reflect.DeepEqual(body.Providers, src.enabled) {
		t.Fatalf("body with a source = %s", rec.Body.String())
	}
}