package yasrpc

import (
	"crypto/tls"
	"fmt"
	"html/template"
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"reflect"
	"regexp"
	"testing"
	"time"

	"git.yasdb.com/go/yasutil/assert"
)

func formatAsDate(t time.Time) string {
	year, month, day := t.Date()
	return fmt.Sprintf("%d/%02d/%02d", year, month, day)
}

func setupHTMLFiles(t *testing.T, tls bool, loadMethod func(*Engine)) *httptest.Server {
	router := NewEngine()
	router.Delims("{[{", "}]}")
	router.SetFuncMap(template.FuncMap{
		"formatAsDate": formatAsDate,
	})
	loadMethod(router)
	router.GET("/test", func(c *Context) {
		c.HTML(http.StatusOK, "hello.tmpl", map[string]string{"name": "world"})
	})
	router.GET("/raw", func(c *Context) {
		c.HTML(http.StatusOK, "raw.tmpl", map[string]any{
			"now": time.Date(2023, 06, 21, 0, 0, 0, 0, time.UTC),
		})
	})

	var ts *httptest.Server

	if tls {
		ts = httptest.NewTLSServer(router)
	} else {
		ts = httptest.NewServer(router)
	}

	return ts
}

func TestCreateEngine(t *testing.T) {
	ast := assert.NewAssert(t)

	router := NewEngine()
	ast.Equal("/", router.basePath)
	ast.Equal(router.engine, router)
	ast.Equal(len(router.Middlewares), 0)
}

func TestLoadHTMLGlob(t *testing.T) {
	ast := assert.NewAssert(t)

	ts := setupHTMLFiles(t, false, func(e *Engine) {
		e.LoadHTMLGlob("./testdata/template/*")
	})
	defer ts.Close()

	res, err := http.Get(fmt.Sprintf("%s/test", ts.URL))
	ast.Nil(err)

	resp, _ := io.ReadAll(res.Body)
	ast.Equal("<h1>Hello world</h1>", string(resp))
}

func TestLoadHTMLGlobUsingTLS(t *testing.T) {
	ast := assert.NewAssert(t)

	ts := setupHTMLFiles(t, true, func(e *Engine) {
		e.LoadHTMLGlob("./testdata/template/*")
	})
	defer ts.Close()

	tr := &http.Transport{
		TLSClientConfig: &tls.Config{
			InsecureSkipVerify: true,
		},
	}
	client := &http.Client{Transport: tr}
	res, err := client.Get(fmt.Sprintf("%s/test", ts.URL))
	ast.Nil(err)

	resp, _ := io.ReadAll(res.Body)
	ast.Equal("<h1>Hello world</h1>", string(resp))
}

func TestLoadHTMLGlobFuncMap(t *testing.T) {
	ast := assert.NewAssert(t)

	ts := setupHTMLFiles(t, false, func(e *Engine) {
		e.LoadHTMLGlob("./testdata/template/*")
	})
	defer ts.Close()

	res, err := http.Get(fmt.Sprintf("%s/raw", ts.URL))
	ast.Nil(err)

	resp, _ := io.ReadAll(res.Body)
	ast.Equal("Date: 2023/06/21", string(resp))
}

func TestLoadHTMLFilesTestMode(t *testing.T) {
	ast := assert.NewAssert(t)

	ts := setupHTMLFiles(t, false, func(e *Engine) {
		e.LoadHTMLFiles("./testdata/template/hello.tmpl", "./testdata/template/raw.tmpl")
	})
	defer ts.Close()

	res, err := http.Get(fmt.Sprintf("%s/test", ts.URL))
	ast.Nil(err)

	resp, _ := io.ReadAll(res.Body)
	ast.Equal("<h1>Hello world</h1>", string(resp))
}

func TestLoadHTMLFilesUsingTLS(t *testing.T) {
	ast := assert.NewAssert(t)

	ts := setupHTMLFiles(t, true, func(e *Engine) {
		e.LoadHTMLFiles("./testdata/template/hello.tmpl", "./testdata/template/raw.tmpl")
	})
	defer ts.Close()

	tr := &http.Transport{
		TLSClientConfig: &tls.Config{
			InsecureSkipVerify: true,
		},
	}
	client := &http.Client{Transport: tr}
	res, err := client.Get(fmt.Sprintf("%s/test", ts.URL))
	ast.Nil(err)

	resp, _ := io.ReadAll(res.Body)
	ast.Equal("<h1>Hello world</h1>", string(resp))
}

func TestLoadHTMLFilesFuncMap(t *testing.T) {
	ast := assert.NewAssert(t)

	ts := setupHTMLFiles(t, false, func(e *Engine) {
		e.LoadHTMLFiles("./testdata/template/hello.tmpl", "./testdata/template/raw.tmpl")
	})
	defer ts.Close()

	res, err := http.Get(fmt.Sprintf("%s/raw", ts.URL))
	if err != nil {
		t.Error(err)
	}

	resp, _ := io.ReadAll(res.Body)
	ast.Equal("Date: 2023/06/21", string(resp))
}

func TestAddRoute(t *testing.T) {
	ast := assert.NewAssert(t)

	router := NewEngine()
	router.addRoute("GET", "/", HandlersChain{func(_ *Context) {}})

	ast.Equal(len(router.trees), 1)
	ast.NotNil(router.trees.get("GET"))
	ast.Nil(router.trees.get("POST"))

	router.addRoute("POST", "/", HandlersChain{func(_ *Context) {}})

	ast.Equal(len(router.trees), 2)
	ast.NotNil(router.trees.get("GET"))
	ast.NotNil(router.trees.get("POST"))

	router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}})
	ast.Equal(len(router.trees), 2)
}

func TestCreateDefaultRouter(t *testing.T) {
	ast := assert.NewAssert(t)

	router := DefaultEngine()
	ast.Equal(len(router.Middlewares), 2)
}

func TestGlobalHandlers(t *testing.T) {
	ast := assert.NewAssert(t)

	var middleware1 HandlerFunc = func(c *Context) {}
	var middleware2 HandlerFunc = func(c *Context) {}

	router := NewEngine()
	router.Use(middleware2)
	ast.Equal(len(router.Middlewares), 1)
	compareFunc(t, router.Middlewares[0], middleware2)

	router.Use(middleware1)
	ast.Equal(len(router.Middlewares), 2)
	compareFunc(t, router.Middlewares[0], middleware2)
	compareFunc(t, router.Middlewares[1], middleware1)
}

func compareFunc(t *testing.T, a, b any) {
	sf1 := reflect.ValueOf(a)
	sf2 := reflect.ValueOf(b)
	if sf1.Pointer() != sf2.Pointer() {
		t.Error("different functions")
	}
}

func TestListOfRoutes(t *testing.T) {
	ast := assert.NewAssert(t)

	router := NewEngine()
	router.GET("/favicon.ico", handlerTest1)
	router.GET("/", handlerTest1)
	group := router.Group("/users")
	{
		group.GET("/", handlerTest2)
		group.GET("/:id", handlerTest1)
		group.POST("/:id", handlerTest2)
	}
	router.Static("/static", ".")

	list := router.Routes()

	ast.Equal(len(list), 7)
	assertRoutePresent(t, list, RouteInfo{
		Method:  "GET",
		Path:    "/favicon.ico",
		Handler: "yasrpc.handlerTest1$",
	})
	assertRoutePresent(t, list, RouteInfo{
		Method:  "GET",
		Path:    "/",
		Handler: "yasrpc.handlerTest1$",
	})
	assertRoutePresent(t, list, RouteInfo{
		Method:  "GET",
		Path:    "/users/",
		Handler: "yasrpc.handlerTest2$",
	})
	assertRoutePresent(t, list, RouteInfo{
		Method:  "GET",
		Path:    "/users/:id",
		Handler: "yasrpc.handlerTest1$",
	})
	assertRoutePresent(t, list, RouteInfo{
		Method:  "POST",
		Path:    "/users/:id",
		Handler: "yasrpc.handlerTest2$",
	})
}

func assertRoutePresent(t *testing.T, gotRoutes RoutesInfo, wantRoute RouteInfo) {
	for _, gotRoute := range gotRoutes {
		if gotRoute.Path == wantRoute.Path && gotRoute.Method == wantRoute.Method {
			r := regexp.MustCompile(wantRoute.Handler)
			if r.FindStringIndex(gotRoute.Handler) == nil {
				t.Error("regexp error")
			}
			return
		}
	}
	t.Errorf("route not found: %v", wantRoute)
}

func handlerTest1(c *Context) {}
func handlerTest2(c *Context) {}

func testRequest(ast *assert.Assert, params ...string) {

	ast.False(len(params) == 0)

	tr := &http.Transport{
		TLSClientConfig: &tls.Config{
			InsecureSkipVerify: true,
		},
	}
	client := &http.Client{Transport: tr}

	resp, err := client.Get(params[0])
	ast.Nil(err)
	defer resp.Body.Close()

	body, ioerr := io.ReadAll(resp.Body)
	ast.Nil(ioerr)

	var responseStatus = "200 OK"
	if len(params) > 1 && params[1] != "" {
		responseStatus = params[1]
	}

	var responseBody = "it worked"
	if len(params) > 2 && params[2] != "" {
		responseBody = params[2]
	}

	ast.Equal(responseStatus, resp.Status)
	if responseStatus == "200 OK" {
		ast.Equal(responseBody, string(body))
	}
}

func TestRunEmpty(t *testing.T) {
	ast := assert.NewAssert(t)

	os.Setenv("PORT", "")
	router := NewEngine()
	go func() {
		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
		ast.Nil(router.Run(":8080"))
	}()
	// have to wait for the goroutine to start and run the server
	// otherwise the main thread will complete
	time.Sleep(5 * time.Millisecond)

	ast.NotNil(router.Run(":8080"))
	testRequest(ast, "http://localhost:8080/example")
}