package ginzip

import (
	"compress/gzip"
	"io/ioutil"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/andybalholm/brotli"
	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"
)

const testResponse = "Ginzip Test Response"

func newServer() *gin.Engine {
	return newServerOptions(DefaultOptions())
}

func newServerOptions(options Options) *gin.Engine {
	router := gin.Default()
	router.Use(New(options))

	testResponseHandler := func(c *gin.Context) {
		c.String(200, testResponse)
	}

	router.GET("/", testResponseHandler)
	router.GET("/image.png", testResponseHandler)
	return router
}

func TestUncompressed(t *testing.T) {
	tests := []struct {
		name    string
		uri     string
		accept  string
		options Options
	}{
		{
			name:    "index",
			uri:     "/",
			accept:  "",
			options: DefaultOptions(),
		},
		{
			name:    "index_disabled",
			uri:     "/",
			accept:  "gzip,br",
			options: Options{BrotliLevel: "false", GzipLevel: "false"},
		},
		{
			name:    "png",
			uri:     "/image.png",
			accept:  "gzip,br",
			options: Options{}.IgnoreExt(".png"),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			req, _ := http.NewRequest("GET", tt.uri, nil)
			req.Header.Add("Accept-Encoding", tt.accept)

			w := httptest.NewRecorder()
			r := newServerOptions(tt.options)
			r.ServeHTTP(w, req)

			assert.Equal(t, w.Code, 200)
			assert.Equal(t, "", w.Header().Get("Content-Encoding"))
			assert.Equal(t, "", w.Header().Get("Vary"))
			assert.Equal(t, testResponse, w.Body.String())
		})
	}
}

func TestGzip(t *testing.T) {
	tests := []struct {
		name    string
		uri     string
		accept  string
		options Options
	}{
		{
			name:    "index",
			uri:     "/",
			accept:  "gzip",
			options: DefaultOptions(),
		},
		{
			name:    "index_br_disabled",
			uri:     "/",
			accept:  "gzip,br",
			options: Options{BrotliLevel: "false"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			req, _ := http.NewRequest("GET", tt.uri, nil)
			req.Header.Add("Accept-Encoding", tt.accept)

			w := httptest.NewRecorder()
			r := newServerOptions(tt.options)
			r.ServeHTTP(w, req)

			assert.Equal(t, w.Code, 200)
			assert.Equal(t, "gzip", w.Header().Get("Content-Encoding"))
			assert.Equal(t, "Accept-Encoding", w.Header().Get("Vary"))
			assert.NotEqual(t, len(testResponse), w.Body.Len())

			gr, err := gzip.NewReader(w.Body)
			assert.NoError(t, err)
			defer gr.Close()

			body, err := ioutil.ReadAll(gr)
			assert.NoError(t, err)
			assert.Equal(t, string(body), testResponse)
		})
	}
}

func TestBrotli(t *testing.T) {
	tests := []struct {
		name    string
		uri     string
		accept  string
		options Options
	}{
		{
			name:    "index",
			uri:     "/",
			accept:  "gzip,br",
			options: DefaultOptions(),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			req, _ := http.NewRequest("GET", tt.uri, nil)
			req.Header.Add("Accept-Encoding", tt.accept)

			w := httptest.NewRecorder()
			r := newServerOptions(tt.options)
			r.ServeHTTP(w, req)

			assert.Equal(t, w.Code, 200)
			assert.Equal(t, "br", w.Header().Get("Content-Encoding"))
			assert.Equal(t, "Accept-Encoding", w.Header().Get("Vary"))
			assert.NotEqual(t, len(testResponse), w.Body.Len())

			br := brotli.NewReader(w.Body)

			body, err := ioutil.ReadAll(br)
			assert.NoError(t, err)
			assert.Equal(t, string(body), testResponse)
		})
	}
}