package main

import (
	"fmt"
	"net/http"
	"os"

	"github.com/labstack/echo/v4"
)

type Response struct {
	Ret     int         `json:"ret"`
	Message string      `json:"message"`
	Data    interface{} `json:"data"`
}

func unifiedResponseHandler(next echo.HandlerFunc) echo.HandlerFunc {
	return func(c echo.Context) error {
		err := next(c)
		if err != nil {
			// Let the custom HTTP error handler handle the error
			fmt.Fprintf(os.Stderr, "print error: %v", err)
			return err
		}

		// Handle successful responses
		ret, _ := c.Get("ret").(int)
		msg, _ := c.Get("msg").(string)
		response := c.Get("response")
		return c.JSON(http.StatusOK, Response{
			Ret:     ret,
			Message: msg,
			Data:    response,
		})
	}
}

// Custom HTTP error handler
func customHTTPErrorHandler(err error, c echo.Context) {
	var (
		code    = http.StatusInternalServerError
		message = "Internal Server Error"
	)

	if he, ok := err.(*echo.HTTPError); ok {
		code = he.Code
		message = he.Message.(string)
	}

	c.JSON(http.StatusOK, Response{
		Ret:     code,
		Message: message,
		Data:    nil,
	})
}

// Helper function to set the response
func setResponse(c echo.Context, data interface{}) {
	c.Set("ret", 0)
	c.Set("msg", "success")
	c.Set("response", data)
}

// Helper function to set the response
func setErrResponse(c echo.Context, ret int, msg string) {
	c.Set("ret", ret)
	c.Set("msg", msg)
	c.Set("response", nil)
}

/*
func unifiedResponseHandler(next echo.HandlerFunc) echo.HandlerFunc {
	return func(c echo.Context) error {
		err := next(c)
		if err != nil {
			c.Error(err)
		}

		// Retrieve the response
		if he, ok := err.(*echo.HTTPError); ok {
			return c.JSON(http.StatusOK, Response{
				Ret:     he.Code,
				Message: he.Message.(string),
				Data:    nil,
			})
		}

		// Handle successful responses
		response := c.Get("response")
		return c.JSON(http.StatusOK, Response{
			Ret:     0,
			Message: "success",
			Data:    response,
		})
	}
}
*/