package ginext

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/rs/zerolog/log"
	"gogs.mikescher.com/BlackForestBytes/goext/ginext/apierr"
	json "gogs.mikescher.com/BlackForestBytes/goext/gojson"
	"gogs.mikescher.com/BlackForestBytes/goext/langext"
	"runtime/debug"
	"strings"
)

type HTTPResponse interface {
	Write(g *gin.Context)
}

type jsonHTTPResponse struct {
	statusCode int
	data       any
}

func (j jsonHTTPResponse) Write(g *gin.Context) {
	g.Render(j.statusCode, json.GoJsonRender{Data: j.data, NilSafeSlices: true, NilSafeMaps: true})
}

type emptyHTTPResponse struct {
	statusCode int
}

func (j emptyHTTPResponse) Write(g *gin.Context) {
	g.Status(j.statusCode)
}

type textHTTPResponse struct {
	statusCode int
	data       string
}

func (j textHTTPResponse) Write(g *gin.Context) {
	g.String(j.statusCode, "%s", j.data)
}

type dataHTTPResponse struct {
	statusCode  int
	data        []byte
	contentType string
}

func (j dataHTTPResponse) Write(g *gin.Context) {
	g.Data(j.statusCode, j.contentType, j.data)
}

type fileHTTPResponse struct {
	mimetype string
	filepath string
	filename *string
}

func (j fileHTTPResponse) Write(g *gin.Context) {
	g.Header("Content-Type", j.mimetype) // if we don't set it here gin does weird file-sniffing later...
	if j.filename != nil {
		g.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", *j.filename))

	}
	g.File(j.filepath)
}

func Status(sc int) HTTPResponse {
	return &emptyHTTPResponse{statusCode: sc}
}

func JSON(sc int, data any) HTTPResponse {
	return &jsonHTTPResponse{statusCode: sc, data: data}
}

func Data(sc int, contentType string, data []byte) HTTPResponse {
	return &dataHTTPResponse{statusCode: sc, contentType: contentType, data: data}
}

func Text(sc int, data string) HTTPResponse {
	return &textHTTPResponse{statusCode: sc, data: data}
}

func File(mimetype string, filepath string) HTTPResponse {
	return &fileHTTPResponse{mimetype: mimetype, filepath: filepath}
}

func Download(mimetype string, filepath string, filename string) HTTPResponse {
	return &fileHTTPResponse{mimetype: mimetype, filepath: filepath, filename: &filename}
}

func APIError(g *gin.Context, errcode apierr.APIErrorCode, msg string, e error) HTTPResponse {
	return createApiError(g, errcode, msg, e)
}

func NotImplemented(g *gin.Context) HTTPResponse {
	return createApiError(g, apierr.NotImplemented, "", nil)
}

func createApiError(g *gin.Context, errcode apierr.APIErrorCode, msg string, e error) HTTPResponse {
	reqUri := ""
	if g != nil && g.Request != nil {
		reqUri = g.Request.Method + " :: " + g.Request.RequestURI
	}

	log.Error().
		Str("errorcode.key", errcode.Key).
		Int("errcode.status", errcode.HTTPStatusCode).
		Str("uri", reqUri).
		AnErr("err", e).
		Stack().
		Msg(msg)

	var fapiMessage *string = nil
	if v, ok := e.(interface{ FAPIMessage() string }); ok {
		fapiMessage = langext.Ptr(v.FAPIMessage())
	}

	if g.GetBool("__returnRawErrors") {
		return &jsonHTTPResponse{
			statusCode: errcode.HTTPStatusCode,
			data: extAPIError{
				ErrorCode:        errcode.Key,
				Message:          msg,
				RawError:         langext.Ptr(langext.Conditional(e == nil, "", fmt.Sprintf("%+v", e))),
				FAPIErrorMessage: fapiMessage,
				Trace:            strings.Split(string(debug.Stack()), "\n"),
			},
		}
	} else {
		return &jsonHTTPResponse{
			statusCode: errcode.HTTPStatusCode,
			data: apiError{
				ErrorCode:        errcode.Key,
				Message:          msg,
				FAPIErrorMessage: fapiMessage,
			},
		}
	}
}