package chizap_test

import (
	"net/http"
	"net/http/httptest"
	"testing"

	"gitea.dwysokinski.me/Kichiyaki/chizap"
	"github.com/go-chi/chi/v5"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap"
	"go.uber.org/zap/zaptest/observer"
)

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

	t.Run("OK: status code=200", func(t *testing.T) {
		t.Parallel()

		logger, obs := newLogger()

		router := chi.NewRouter()
		router.Use(chizap.Logger(logger))
		router.Get("/info", func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
		})

		req, err := http.NewRequest("GET", "/info?test=true", nil)
		assert.NoError(t, err)
		router.ServeHTTP(httptest.NewRecorder(), req)

		entries := obs.TakeAll()
		require.Len(t, entries, 1)
		assert.Equal(t, "/info", entries[0].Message)
		assert.Equal(t, zap.InfoLevel, entries[0].Level)
	})

	t.Run("OK: status code=400", func(t *testing.T) {
		t.Parallel()

		logger, obs := newLogger()

		router := chi.NewRouter()
		router.Use(chizap.Logger(logger))
		router.Get("/warn", func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusBadRequest)
		})

		req, err := http.NewRequest("GET", "/warn", nil)
		assert.NoError(t, err)
		router.ServeHTTP(httptest.NewRecorder(), req)

		entries := obs.TakeAll()
		require.Len(t, entries, 1)
		assert.Equal(t, "/warn", entries[0].Message)
		assert.Equal(t, zap.WarnLevel, entries[0].Level)
	})

	t.Run("OK: status code=500", func(t *testing.T) {
		t.Parallel()

		logger, obs := newLogger()

		router := chi.NewRouter()
		router.Use(chizap.Logger(logger))
		router.Get("/error", func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusInternalServerError)
		})

		req, err := http.NewRequest("GET", "/error", nil)
		assert.NoError(t, err)
		router.ServeHTTP(httptest.NewRecorder(), req)

		entries := obs.TakeAll()
		require.Len(t, entries, 1)
		assert.Equal(t, "/error", entries[0].Message)
		assert.Equal(t, zap.ErrorLevel, entries[0].Level)
	})

	t.Run("OK: path should be skipped", func(t *testing.T) {
		t.Parallel()

		logger, obs := newLogger()

		router := chi.NewRouter()
		router.Use(chizap.Logger(
			logger,
			chizap.WithFilter(func(r *http.Request) bool {
				return r.URL.Path != "/anythingelse"
			}),
			chizap.WithFilter(func(r *http.Request) bool {
				return r.URL.Path != "/error"
			}),
		))
		router.Get("/error", func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusInternalServerError)
		})
		router.Get("/success", func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
		})

		req1, err := http.NewRequest("GET", "/error", nil)
		assert.NoError(t, err)
		router.ServeHTTP(httptest.NewRecorder(), req1)

		req2, err := http.NewRequest("GET", "/success", nil)
		assert.NoError(t, err)
		router.ServeHTTP(httptest.NewRecorder(), req2)

		entries := obs.TakeAll()
		require.Len(t, entries, 1)
		assert.Equal(t, "/success", entries[0].Message)
		assert.Equal(t, zap.InfoLevel, entries[0].Level)
	})
}

func newLogger() (*zap.Logger, *observer.ObservedLogs) {
	core, obs := observer.New(zap.NewAtomicLevelAt(zap.InfoLevel))
	logger := zap.New(core)
	return logger, obs
}