package main

import (
	"context"
	"io"
	"net/http"
	"net/http/httptest"
	"testing"
	"testing/synctest"
	"time"

	"github.com/stretchr/testify/require"
)

func TestGetUpdatesAsksForMessagesFromTheOffset(t *testing.T) {
	server := newTelegramFake(t)
	server.Add(TelegramUpdate{
		UpdateID: 7,
		Message:  telegramOwnerMessage("hello"),
	})

	updates, err := newTelegramAPI(server.URL, telegramTestToken).GetUpdates(t.Context(), 7)
	require.NoError(t, err)
	require.Len(t, updates, 1)
	require.Equal(t, int64(7), updates[0].UpdateID)
	require.Equal(t, "hello", updates[0].Message.Text)

	call := server.Calls()[0]
	require.Equal(t, "getUpdates", call.method)
	require.Equal(t, map[string]any{
		"offset":          float64(7),
		"timeout":         float64(telegramPollSeconds),
		"allowed_updates": []any{"message"},
	}, call.params)
}

func TestSendMessageSendsPlainText(t *testing.T) {
	server := newTelegramFake(t)
	err := newTelegramAPI(server.URL, telegramTestToken).SendMessage(t.Context(), telegramTestOwner, "*not bold*", nil)
	require.NoError(t, err)

	require.Equal(t, map[string]any{
		"chat_id": float64(telegramTestOwner),
		"text":    "*not bold*",
	}, server.Calls()[0].params)
}

func TestSendMessageSendsTheEntities(t *testing.T) {
	server := newTelegramFake(t)
	err := newTelegramAPI(server.URL, telegramTestToken).SendMessage(t.Context(), telegramTestOwner, "a link", []TelegramEntity{
		{
			Type:   "text_link",
			Offset: 2,
			Length: 4,
			URL:    "https://example.com",
		},
	})
	require.NoError(t, err)

	require.Equal(t, []any{
		map[string]any{
			"type":   "text_link",
			"offset": float64(2),
			"length": float64(4),
			"url":    "https://example.com",
		},
	}, server.Calls()[0].params["entities"])
}

func TestSendRichMessageSendsTheMarkdownUnchanged(t *testing.T) {
	server := newTelegramFake(t)
	markdown := "| a | b |\n|---|---|\n| **1** | `2` |"
	err := newTelegramAPI(server.URL, telegramTestToken).SendRichMessage(t.Context(), telegramTestOwner, markdown)
	require.NoError(t, err)

	call := server.Calls()[0]
	require.Equal(t, "sendRichMessage", call.method)
	require.Equal(t, map[string]any{
		"chat_id": float64(telegramTestOwner),
		"rich_message": map[string]any{
			"markdown": markdown,
		},
	}, call.params)
}

func TestSendCallsTimeOutOnAStalledConnection(t *testing.T) {
	testCases := []struct {
		method string
		send   func(ctx context.Context, api *TelegramAPI) error
	}{
		{
			method: "sendMessage",
			send: func(ctx context.Context, api *TelegramAPI) error {
				return api.SendMessage(ctx, telegramTestOwner, "hi", nil)
			},
		},
		{
			method: "sendRichMessage",
			send: func(ctx context.Context, api *TelegramAPI) error {
				return api.SendRichMessage(ctx, telegramTestOwner, "hi")
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.method, func(t *testing.T) {
			synctest.Test(t, func(t *testing.T) {
				server := newTelegramLocalFake(t)
				server.stall = func(call TelegramFakeCall) bool {
					return call.method == tc.method
				}

				api := newTelegramAPI(server.URL, telegramTestToken)
				api.http.Transport = server
				start := time.Now()
				err := tc.send(t.Context(), api)
				require.EqualError(t, err, "no answer in 30s")
				require.Equal(t, telegramSendTimeout, time.Since(start))
				require.NotContains(t, err.Error(), telegramTestToken)
				require.NotContains(t, err.Error(), server.URL)

				retry, _ := telegramRetryable(err)
				require.True(t, retry)

				ctx, cancel := context.WithCancel(t.Context())
				defer cancel()

				time.AfterFunc(time.Second, cancel)

				start = time.Now()
				err = tc.send(ctx, api)
				require.Error(t, err)
				require.Equal(t, time.Second, time.Since(start))
			})
		})
	}
}

func TestBotErrorsDoNotHoldTheToken(t *testing.T) {
	testCases := []struct {
		name      string
		reply     func(w http.ResponseWriter)
		retry     bool
		wait      time.Duration
		rejected  bool
		errorText string
	}{
		{
			name: "refused connection is retried",
			reply: func(w http.ResponseWriter) {
				conn, _, err := http.NewResponseController(w).Hijack()
				if err == nil {
					_ = conn.Close()
				}
			},
			retry:     true,
			errorText: "no answer",
		},
		{
			name: "rate limit waits as asked",
			reply: func(w http.ResponseWriter) {
				w.WriteHeader(http.StatusTooManyRequests)

				_, _ = io.WriteString(w, `{"ok":false,"error_code":429,"description":"Too Many Requests: retry after 3","parameters":{"retry_after":3}}`)
			},
			retry:     true,
			wait:      3 * time.Second,
			errorText: "429",
		},
		{
			name: "server error page is retried",
			reply: func(w http.ResponseWriter) {
				w.WriteHeader(http.StatusBadGateway)

				_, _ = io.WriteString(w, "<html>bad gateway</html>")
			},
			retry:     true,
			errorText: "502 Bad Gateway",
		},
		{
			name: "token echoed in a description is hidden",
			reply: func(w http.ResponseWriter) {
				w.WriteHeader(http.StatusUnauthorized)

				_, _ = io.WriteString(w, `{"ok":false,"error_code":401,"description":"Unauthorized: bot`+telegramTestToken+`"}`)
			},
			retry:     false,
			errorText: "Unauthorized: botTOKEN",
		},
		{
			name: "bad request is a refusal",
			reply: func(w http.ResponseWriter) {
				w.WriteHeader(http.StatusBadRequest)

				_, _ = io.WriteString(w, `{"ok":false,"error_code":400,"description":"Bad Request: can't parse"}`)
			},
			retry:     false,
			rejected:  true,
			errorText: "400 Bad Request: can't parse",
		},
		{
			name: "unknown method is a refusal",
			reply: func(w http.ResponseWriter) {
				w.WriteHeader(http.StatusNotFound)

				_, _ = io.WriteString(w, `{"ok":false,"error_code":404,"description":"Not Found"}`)
			},
			retry:     false,
			rejected:  true,
			errorText: "404 Not Found",
		},
		{
			name: "not found page of a proxy is not a refusal",
			reply: func(w http.ResponseWriter) {
				w.WriteHeader(http.StatusNotFound)

				_, _ = io.WriteString(w, "<html>not found</html>")
			},
			retry:     false,
			errorText: "404 Not Found",
		},
		{
			name: "broken answer is retried",
			reply: func(w http.ResponseWriter) {
				_, _ = io.WriteString(w, `{"ok":`)
			},
			retry:     true,
			errorText: "invalid JSON",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
				tc.reply(w)
			}))
			t.Cleanup(server.Close)

			err := newTelegramAPI(server.URL, telegramTestToken).SendMessage(t.Context(), telegramTestOwner, "hi", nil)
			require.ErrorContains(t, err, tc.errorText)
			require.NotContains(t, err.Error(), telegramTestToken)
			require.NotContains(t, err.Error(), server.URL)

			retry, wait := telegramRetryable(err)
			require.Equal(t, tc.retry, retry)
			require.Equal(t, tc.wait, wait)
			require.Equal(t, tc.rejected, telegramRejected(err))
		})
	}

	server := httptest.NewServer(http.NotFoundHandler())
	server.Close()

	_, err := newTelegramAPI(server.URL, telegramTestToken).GetUpdates(t.Context(), 0)
	require.ErrorAs(t, err, new(*TelegramNetworkError))
	require.NotContains(t, err.Error(), telegramTestToken)
}