package internalhttp

import (
	"context"
	"encoding/json"
	"io"
	"net"
	"net/http"
	"strings"
	"testing"
	"time"

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

func TestNewServerRejectsInvalidConfiguration(t *testing.T) {
	t.Parallel()

	cfg := Config{
		ReadHeaderTimeout: time.Second,
		ReadTimeout:       time.Second,
		IdleTimeout:       time.Second,
	}

	_, err := NewServer(cfg, Dependencies{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "addr")
}

func TestServerRunAndShutdown(t *testing.T) {
	t.Parallel()

	cfg := testConfig(t)
	server, err := NewServer(cfg, Dependencies{})
	require.NoError(t, err)

	runErr := make(chan error, 1)
	go func() {
		runErr <- server.Run(context.Background())
	}()

	client := newTestHTTPClient(t)
	waitForHealthzReady(t, client, cfg.Addr)

	shutdownCtx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	require.NoError(t, server.Shutdown(shutdownCtx))
	waitForServerRunResult(t, runErr)
}

func TestProbeRoutesReturnStableJSON(t *testing.T) {
	t.Parallel()

	cfg := testConfig(t)
	server, err := NewServer(cfg, Dependencies{})
	require.NoError(t, err)

	runErr := make(chan error, 1)
	go func() {
		runErr <- server.Run(context.Background())
	}()

	client := newTestHTTPClient(t)
	waitForHealthzReady(t, client, cfg.Addr)

	tests := []struct {
		path   string
		status string
	}{
		{path: HealthzPath, status: "ok"},
		{path: ReadyzPath, status: "ready"},
	}

	for _, tt := range tests {
		tt := tt

		t.Run(tt.path, func(t *testing.T) {
			request, err := http.NewRequest(http.MethodGet, "http://"+cfg.Addr+tt.path, nil)
			require.NoError(t, err)

			response, err := client.Do(request)
			require.NoError(t, err)
			defer response.Body.Close()

			require.Equal(t, http.StatusOK, response.StatusCode)
			require.Equal(t, "application/json; charset=utf-8", response.Header.Get("Content-Type"))

			var payload statusResponse
			require.NoError(t, json.NewDecoder(response.Body).Decode(&payload))
			require.Equal(t, tt.status, payload.Status)
		})
	}

	shutdownCtx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	require.NoError(t, server.Shutdown(shutdownCtx))
	waitForServerRunResult(t, runErr)
}

func TestServerDoesNotExposeMetricsOrUnknownRoutes(t *testing.T) {
	t.Parallel()

	cfg := testConfig(t)
	server, err := NewServer(cfg, Dependencies{})
	require.NoError(t, err)

	runErr := make(chan error, 1)
	go func() {
		runErr <- server.Run(context.Background())
	}()

	client := newTestHTTPClient(t)
	waitForHealthzReady(t, client, cfg.Addr)

	for _, path := range []string{"/metrics", "/unknown"} {
		request, err := http.NewRequest(http.MethodGet, "http://"+cfg.Addr+path, nil)
		require.NoError(t, err)

		response, err := client.Do(request)
		require.NoError(t, err)
		_, _ = io.ReadAll(response.Body)
		response.Body.Close()

		assert.Equalf(t, http.StatusNotFound, response.StatusCode, "path %s", path)
	}

	shutdownCtx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	require.NoError(t, server.Shutdown(shutdownCtx))
	waitForServerRunResult(t, runErr)
}

func TestServerPreservesStandardHEADBehavior(t *testing.T) {
	t.Parallel()

	cfg := testConfig(t)
	server, err := NewServer(cfg, Dependencies{})
	require.NoError(t, err)

	runErr := make(chan error, 1)
	go func() {
		runErr <- server.Run(context.Background())
	}()

	client := newTestHTTPClient(t)
	waitForHealthzReady(t, client, cfg.Addr)

	request, err := http.NewRequest(http.MethodHead, "http://"+cfg.Addr+HealthzPath, nil)
	require.NoError(t, err)

	response, err := client.Do(request)
	require.NoError(t, err)
	defer response.Body.Close()

	body, err := io.ReadAll(response.Body)
	require.NoError(t, err)
	require.Equal(t, http.StatusOK, response.StatusCode)
	require.Empty(t, body)

	shutdownCtx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	require.NoError(t, server.Shutdown(shutdownCtx))
	waitForServerRunResult(t, runErr)
}

func TestServerUsesStandardMethodNotAllowedBehavior(t *testing.T) {
	t.Parallel()

	cfg := testConfig(t)
	server, err := NewServer(cfg, Dependencies{})
	require.NoError(t, err)

	runErr := make(chan error, 1)
	go func() {
		runErr <- server.Run(context.Background())
	}()

	client := newTestHTTPClient(t)
	waitForHealthzReady(t, client, cfg.Addr)

	request, err := http.NewRequest(http.MethodPost, "http://"+cfg.Addr+HealthzPath, nil)
	require.NoError(t, err)

	response, err := client.Do(request)
	require.NoError(t, err)
	defer response.Body.Close()
	_, _ = io.ReadAll(response.Body)

	require.Equal(t, http.StatusMethodNotAllowed, response.StatusCode)
	require.Contains(t, response.Header.Get("Allow"), http.MethodGet)
	require.Contains(t, response.Header.Get("Allow"), http.MethodHead)

	shutdownCtx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	require.NoError(t, server.Shutdown(shutdownCtx))
	waitForServerRunResult(t, runErr)
}

func testConfig(t *testing.T) Config {
	t.Helper()

	return Config{
		Addr:              mustFreeAddr(t),
		ReadHeaderTimeout: time.Second,
		ReadTimeout:       2 * time.Second,
		IdleTimeout:       time.Minute,
	}
}

func newTestHTTPClient(t *testing.T) *http.Client {
	t.Helper()

	transport := &http.Transport{DisableKeepAlives: true}
	t.Cleanup(transport.CloseIdleConnections)

	return &http.Client{
		Timeout:   250 * time.Millisecond,
		Transport: transport,
	}
}

func waitForHealthzReady(t *testing.T, client *http.Client, addr string) {
	t.Helper()

	require.Eventually(t, func() bool {
		request, err := http.NewRequest(http.MethodGet, "http://"+addr+HealthzPath, nil)
		if err != nil {
			return false
		}

		response, err := client.Do(request)
		if err != nil {
			return false
		}
		defer response.Body.Close()

		payload, err := io.ReadAll(response.Body)
		if err != nil {
			return false
		}

		return response.StatusCode == http.StatusOK && strings.Contains(string(payload), `"status":"ok"`)
	}, 5*time.Second, 25*time.Millisecond, "internal HTTP server did not become reachable")
}

func waitForServerRunResult(t *testing.T, runErr <-chan error) {
	t.Helper()

	var err error
	require.Eventually(t, func() bool {
		select {
		case err = <-runErr:
			return true
		default:
			return false
		}
	}, 5*time.Second, 10*time.Millisecond, "internal HTTP server did not stop")
	require.NoError(t, err)
}

func mustFreeAddr(t *testing.T) string {
	t.Helper()

	listener, err := net.Listen("tcp", "127.0.0.1:0")
	require.NoError(t, err)
	defer func() {
		assert.NoError(t, listener.Close())
	}()

	return listener.Addr().String()
}