package handler

import (
	"encoding/json"
	"errors"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	rErrors "codeberg.org/danjones000/responsable-errors"
	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/suite"
)

func TestMiddleware(t *testing.T) {
	suite.Run(t, new(MiddlewareTestSuite))
}

type MiddlewareTestSuite struct {
	suite.Suite
	w   *httptest.ResponseRecorder
	ctx *gin.Context
}

func (s *MiddlewareTestSuite) SetupTest() {
	gin.SetMode(gin.TestMode)
	s.w = httptest.NewRecorder()
	s.ctx, _ = gin.CreateTestContext(s.w)
	s.ctx.Request = new(http.Request)
}

func (s *MiddlewareTestSuite) TearDownTest() {
	s.w = nil
	s.ctx = nil
}

func (s *MiddlewareTestSuite) do(err ...error) {
	for _, e := range err {
		s.ctx.Error(e)
	}
	ErrorMiddleware()(s.ctx)
}

func (s *MiddlewareTestSuite) doParse(err ...error) map[string]any {
	s.do(err...)
	return s.parse()
}

func (s *MiddlewareTestSuite) parse() map[string]any {
	var out map[string]any
	jsonErr := json.Unmarshal(s.w.Body.Bytes(), &out)
	s.Assert().Nil(jsonErr)

	return out
}

func (s *MiddlewareTestSuite) TestNoError() {
	s.do()
	s.Assert().Equal("", s.w.Body.String())
}

func (s *MiddlewareTestSuite) TestResError() {
	msg := "I can't find it"
	err := rErrors.NewNotFound(msg)
	out := s.doParse(err)

	outMsg, ok := out["error"].(string)
	s.Assert().True(ok)
	s.Assert().Equal(msg, outMsg)
	s.Assert().Equal(http.StatusNotFound, s.w.Code)
}

func (s *MiddlewareTestSuite) TestGinError() {
	msg := "I don't like this"
	err := &gin.Error{errors.New(msg), gin.ErrorTypePublic, nil}
	out := s.doParse(err)

	outMsg, ok := out["error"].(string)
	s.Assert().True(ok)
	s.Assert().Equal(msg, outMsg)
	s.Assert().Equal(http.StatusBadRequest, s.w.Code)
}

func (s *MiddlewareTestSuite) TestGinErrorPrivate() {
	msg := "Don't do this"
	err := &gin.Error{errors.New(msg), gin.ErrorTypePrivate, nil}
	out := s.doParse(err)

	outMsg, ok := out["error"].(string)
	s.Assert().True(ok)
	s.Assert().Equal("Unknown Error", outMsg)
	s.Assert().Equal(http.StatusInternalServerError, s.w.Code)
}

func (s *MiddlewareTestSuite) TestOtherError() {
	msg := "Don't do this"
	err := errors.New(msg)
	out := s.doParse(err)

	outMsg, ok := out["error"].(string)
	s.Assert().True(ok)
	s.Assert().Equal("Unknown Error", outMsg)
	s.Assert().Equal(http.StatusInternalServerError, s.w.Code)
}

func (s *MiddlewareTestSuite) TestNoWorkingTransformer() {
	var noop Transformer = func(err error) rErrors.ResponsableError {
		return nil
	}
	err := errors.New("Foo")
	s.ctx.Error(err)
	ErrorMiddleware(WithTransformer(noop))(s.ctx)

	out := s.parse()
	outMsg, ok := out["error"].(string)
	s.Assert().True(ok)
	s.Assert().Equal("Unknown Error", outMsg)
	s.Assert().Equal(http.StatusInternalServerError, s.w.Code)
}

func (s *MiddlewareTestSuite) TestLogger() {
	buff := strings.Builder{}
	var l LoggerFunc = func(c *gin.Context, err rErrors.ResponsableError) {
		buff.WriteString("Err: " + err.Error())
	}
	err := errors.New("Foo")
	s.ctx.Error(err)
	ErrorMiddleware(WithLogger(l))(s.ctx)

	s.Assert().Equal("Err: Foo", buff.String())
}