package connector

import (
	"context"
	"testing"

	flatbuffers "github.com/google/flatbuffers/go"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	"scrabble/pkg/fbs/scrabblefb"
	telegramv1 "scrabble/pkg/proto/telegram/v1"
	"scrabble/platform/telegram/internal/initdata"
	"scrabble/platform/telegram/internal/loginwidget"
)

// stubValidator returns a fixed user / error from Validate.
type stubValidator struct {
	user initdata.User
	err  error
}

func (s stubValidator) Validate(string) (initdata.User, error) { return s.user, s.err }

// stubWidgetValidator returns a fixed user / error from the Login Widget Validate.
type stubWidgetValidator struct {
	user loginwidget.User
	err  error
}

func (s stubWidgetValidator) Validate(string) (loginwidget.User, error) { return s.user, s.err }

// fakeSender records the delivery calls the server makes.
type fakeSender struct {
	notify []notifyCall
	text   []textCall
	err    error
}

type notifyCall struct {
	chatID                       int64
	text, buttonText, startParam string
}
type textCall struct {
	chatID int64
	text   string
}

func (f *fakeSender) Notify(_ context.Context, chatID int64, text, buttonText, startParam string) error {
	f.notify = append(f.notify, notifyCall{chatID, text, buttonText, startParam})
	return f.err
}

func (f *fakeSender) SendText(_ context.Context, chatID int64, text string) error {
	f.text = append(f.text, textCall{chatID, text})
	return f.err
}

// botRT assembles one language-tagged bot runtime for a test.
func botRT(lang string, sender Sender, channelID int64, iv initdata.Validator, wv loginwidget.Validator) BotRuntime {
	return BotRuntime{Language: lang, Sender: sender, ChannelID: channelID, InitValidator: iv, WidgetValidator: wv}
}

func yourTurnPayload(gameID string) []byte {
	b := flatbuffers.NewBuilder(0)
	gid := b.CreateString(gameID)
	scrabblefb.YourTurnEventStart(b)
	scrabblefb.YourTurnEventAddGameId(b, gid)
	b.Finish(scrabblefb.YourTurnEventEnd(b))
	return b.FinishedBytes()
}

func TestValidateInitData(t *testing.T) {
	want := initdata.User{ExternalID: "42", Username: "neo", FirstName: "Thomas", LanguageCode: "en-GB"}
	srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{user: want}, stubWidgetValidator{})}, nil)
	resp, err := srv.ValidateInitData(context.Background(), &telegramv1.ValidateInitDataRequest{InitData: "x"})
	if err != nil {
		t.Fatalf("validate: %v", err)
	}
	if resp.GetExternalId() != "42" || resp.GetUsername() != "neo" || resp.GetFirstName() != "Thomas" || resp.GetLanguageCode() != "en-GB" {
		t.Errorf("resp = %+v, want %+v", resp, want)
	}
	if resp.GetServiceLanguage() != "en" || len(resp.GetSupportedLanguages()) != 1 || resp.GetSupportedLanguages()[0] != "en" {
		t.Errorf("service_language=%q supported=%v, want en / [en]", resp.GetServiceLanguage(), resp.GetSupportedLanguages())
	}

	bad := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{err: initdata.ErrInvalidInitData}, stubWidgetValidator{})}, nil)
	if _, err := bad.ValidateInitData(context.Background(), &telegramv1.ValidateInitDataRequest{}); status.Code(err) != codes.InvalidArgument {
		t.Errorf("err code = %v, want InvalidArgument", status.Code(err))
	}
}

// TestValidateInitDataPicksValidatingBot proves the second bot's token validates and
// its service language is reported when the first bot rejects the data.
func TestValidateInitDataPicksValidatingBot(t *testing.T) {
	want := initdata.User{ExternalID: "7", Username: "ru_user", FirstName: "Иван", LanguageCode: "ru"}
	srv := NewServer([]BotRuntime{
		botRT("en", &fakeSender{}, 0, stubValidator{err: initdata.ErrInvalidInitData}, stubWidgetValidator{}),
		botRT("ru", &fakeSender{}, 0, stubValidator{user: want}, stubWidgetValidator{}),
	}, nil)
	resp, err := srv.ValidateInitData(context.Background(), &telegramv1.ValidateInitDataRequest{InitData: "x"})
	if err != nil {
		t.Fatalf("validate: %v", err)
	}
	if resp.GetExternalId() != "7" || resp.GetServiceLanguage() != "ru" || resp.GetSupportedLanguages()[0] != "ru" {
		t.Errorf("resp = %+v, want external 7 / service ru", resp)
	}
}

func TestValidateLoginWidget(t *testing.T) {
	want := loginwidget.User{ExternalID: "42", Username: "neo", FirstName: "Thomas"}
	srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{user: want})}, nil)
	resp, err := srv.ValidateLoginWidget(context.Background(), &telegramv1.ValidateLoginWidgetRequest{Data: "x"})
	if err != nil {
		t.Fatalf("validate: %v", err)
	}
	if resp.GetExternalId() != "42" || resp.GetUsername() != "neo" || resp.GetFirstName() != "Thomas" {
		t.Errorf("resp = %+v, want %+v", resp, want)
	}

	bad := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{err: loginwidget.ErrInvalidLoginWidget})}, nil)
	if _, err := bad.ValidateLoginWidget(context.Background(), &telegramv1.ValidateLoginWidgetRequest{}); status.Code(err) != codes.InvalidArgument {
		t.Errorf("err code = %v, want InvalidArgument", status.Code(err))
	}
}

func TestNotifyDelivers(t *testing.T) {
	const gameID = "7c9e6679-7425-40de-944b-e07fc1f90ae7"
	sender := &fakeSender{}
	srv := NewServer([]BotRuntime{botRT("en", sender, 0, stubValidator{}, stubWidgetValidator{})}, nil)
	resp, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
		ExternalId: "12345", Kind: "your_turn", Payload: yourTurnPayload(gameID), Language: "en",
	})
	if err != nil {
		t.Fatalf("notify: %v", err)
	}
	if !resp.GetDelivered() {
		t.Fatal("expected delivered=true")
	}
	if len(sender.notify) != 1 {
		t.Fatalf("notify calls = %d, want 1", len(sender.notify))
	}
	if got := sender.notify[0]; got.chatID != 12345 || got.startParam != "g"+gameID {
		t.Errorf("notify call = %+v, want chatID 12345 startParam g%s", got, gameID)
	}
}

// TestNotifyRoutesByLanguage proves the push goes through the bot for the recipient's
// service language, not the other bot.
func TestNotifyRoutesByLanguage(t *testing.T) {
	en, ru := &fakeSender{}, &fakeSender{}
	srv := NewServer([]BotRuntime{
		botRT("en", en, 0, stubValidator{}, stubWidgetValidator{}),
		botRT("ru", ru, 0, stubValidator{}, stubWidgetValidator{}),
	}, nil)
	resp, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
		ExternalId: "12345", Kind: "your_turn", Payload: yourTurnPayload("7c9e6679-7425-40de-944b-e07fc1f90ae7"), Language: "ru",
	})
	if err != nil || !resp.GetDelivered() {
		t.Fatalf("notify: %v delivered=%v", err, resp.GetDelivered())
	}
	if len(ru.notify) != 1 || len(en.notify) != 0 {
		t.Errorf("routing wrong: ru=%d en=%d, want 1/0", len(ru.notify), len(en.notify))
	}
}

// TestNotifyUnknownLanguage proves a push for a language with no bot is a best-effort
// miss (delivered=false, no delivery attempt), not an error.
func TestNotifyUnknownLanguage(t *testing.T) {
	en := &fakeSender{}
	srv := NewServer([]BotRuntime{botRT("en", en, 0, stubValidator{}, stubWidgetValidator{})}, nil)
	resp, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
		ExternalId: "12345", Kind: "your_turn", Payload: yourTurnPayload("g"), Language: "ru",
	})
	if err != nil {
		t.Fatalf("notify: %v", err)
	}
	if resp.GetDelivered() || len(en.notify) != 0 {
		t.Errorf("delivered=%v en calls=%d, want false / 0", resp.GetDelivered(), len(en.notify))
	}
}

func TestNotifySkipsUnrenderedKind(t *testing.T) {
	sender := &fakeSender{}
	srv := NewServer([]BotRuntime{botRT("en", sender, 0, stubValidator{}, stubWidgetValidator{})}, nil)
	resp, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
		ExternalId: "12345", Kind: "opponent_moved", Language: "en",
	})
	if err != nil {
		t.Fatalf("notify: %v", err)
	}
	if resp.GetDelivered() {
		t.Error("expected delivered=false for an unrendered kind")
	}
	if len(sender.notify) != 0 {
		t.Errorf("sender called %d times, want 0", len(sender.notify))
	}
}

func TestNotifyInvalidExternalID(t *testing.T) {
	srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{})}, nil)
	_, err := srv.Notify(context.Background(), &telegramv1.NotifyRequest{
		ExternalId: "not-a-number", Kind: "your_turn", Payload: yourTurnPayload("g"), Language: "en",
	})
	if status.Code(err) != codes.InvalidArgument {
		t.Errorf("err code = %v, want InvalidArgument", status.Code(err))
	}
}

func TestSendToUser(t *testing.T) {
	sender := &fakeSender{}
	srv := NewServer([]BotRuntime{botRT("en", sender, 0, stubValidator{}, stubWidgetValidator{})}, nil)
	resp, err := srv.SendToUser(context.Background(), &telegramv1.SendToUserRequest{ExternalId: "999", Text: "hi", Language: "en"})
	if err != nil {
		t.Fatalf("send to user: %v", err)
	}
	if !resp.GetDelivered() || len(sender.text) != 1 || sender.text[0].chatID != 999 || sender.text[0].text != "hi" {
		t.Errorf("send to user = %v / calls %+v", resp.GetDelivered(), sender.text)
	}
}

// TestSendToUserUnknownLanguage proves the admin broadcast errors when no bot serves
// the operator-chosen language.
func TestSendToUserUnknownLanguage(t *testing.T) {
	srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{})}, nil)
	_, err := srv.SendToUser(context.Background(), &telegramv1.SendToUserRequest{ExternalId: "999", Text: "hi", Language: "ru"})
	if status.Code(err) != codes.FailedPrecondition {
		t.Errorf("err code = %v, want FailedPrecondition", status.Code(err))
	}
}

func TestSendToGameChannel(t *testing.T) {
	t.Run("unconfigured", func(t *testing.T) {
		srv := NewServer([]BotRuntime{botRT("en", &fakeSender{}, 0, stubValidator{}, stubWidgetValidator{})}, nil)
		_, err := srv.SendToGameChannel(context.Background(), &telegramv1.SendToGameChannelRequest{Text: "x", Language: "en"})
		if status.Code(err) != codes.FailedPrecondition {
			t.Errorf("err code = %v, want FailedPrecondition", status.Code(err))
		}
	})
	t.Run("configured routes by language", func(t *testing.T) {
		en, ru := &fakeSender{}, &fakeSender{}
		srv := NewServer([]BotRuntime{
			botRT("en", en, 111, stubValidator{}, stubWidgetValidator{}),
			botRT("ru", ru, 555, stubValidator{}, stubWidgetValidator{}),
		}, nil)
		resp, err := srv.SendToGameChannel(context.Background(), &telegramv1.SendToGameChannelRequest{Text: "news", Language: "ru"})
		if err != nil {
			t.Fatalf("send to channel: %v", err)
		}
		if !resp.GetDelivered() || len(ru.text) != 1 || ru.text[0].chatID != 555 || len(en.text) != 0 {
			t.Errorf("send to channel: ru=%+v en=%+v", ru.text, en.text)
		}
	})
}