package api

import (
	"net/http"
	"unicode"

	"github.com/gin-gonic/gin"
	"github.com/jloup/utils"
)

var CONFIG Config
var MAIL_CONFIG MailConfig

type MailConfig struct {
	IsEnabled   bool
	SmtpAddress string `toml:"smtp_address"`
	AddressFrom string `toml:"address_from"`
	Login       string `toml:"login"`
	Password    string `toml:"password"`
}

type Config struct {
	Domain              string `toml:"domain"`
	JwtSecret           string `toml:"jwt_secret"`
	PasswordResetSecret string `toml:"password_reset_secret"`
	FreeSMSUser         string `toml:"free_sms_user"`
	FreeSMSPass         string `toml:"free_sms_pass"`
}

func SetConfig(config Config) {
	CONFIG = config

	JWT_SECRET = []byte(config.JwtSecret)
	PASSWORD_RESET_SECRET = []byte(config.PasswordResetSecret)
}

func SetMailConfig(config MailConfig) {
	MAIL_CONFIG = config

	if config.Login != "" && config.AddressFrom != "" && config.Password != "" && config.SmtpAddress != "" {
		MAIL_CONFIG.IsEnabled = true
		ConfigureMailTemplateEngine()
	}
}

type Error struct {
	Code        utils.Flag
	UserMessage string
	err         error
}

func (e Error) FlagString() string {
	return e.Code.String()
}

func (e Error) Flag() utils.Flag {
	return e.Code
}

func (e Error) Msg() string {
	return e.UserMessage
}

func (e Error) ErrorWithCode(f utils.Flag) utils.ErrorFlagged {
	if utils.Intersect(e.Code, f) {
		return e
	}

	return nil
}
func (e Error) Err() error {
	if e.err != nil {
		return e
	}

	return nil
}

func (e Error) Error() string {
	if e.err != nil {
		return e.err.Error()
	}

	return ""
}

func ErrorIs(err error, code utils.Flag) bool {
	if err == nil {
		return false
	}

	if apiError, ok := err.(*Error); !ok {
		return false
	} else {
		return utils.Intersect(apiError.Code, code) && apiError.Code.String() == code.String()
	}
}

func NewInternalError(err error) *Error {
	if apiError, ok := err.(*Error); ok {
		return apiError
	}
	return &Error{InternalError, "internal error", err}
}

func ToSnake(in string) string {
	runes := []rune(in)
	length := len(runes)

	var out []rune
	for i := 0; i < length; i++ {
		if i > 0 && unicode.IsUpper(runes[i]) && ((i+1 < length && unicode.IsLower(runes[i+1])) || unicode.IsLower(runes[i-1])) {
			out = append(out, '_')
		}
		out = append(out, unicode.ToLower(runes[i]))
	}

	return string(out)
}

type Response struct {
	StatusCode Status     `json:"-"`
	ErrorCode  utils.Flag `json:"-"`

	Status   string      `json:"status"`
	Code     string      `json:"code,omitempty"`
	Response interface{} `json:"response,omitempty"`
	Message  string      `json:"message,omitempty"`
}

func (r Response) populateStatus() Response {
	r.Status = ToSnake(r.StatusCode.String())
	r.Code = ToSnake(r.ErrorCode.String())

	return r
}

func ErrorResponse(code utils.Flag, message string) Response {
	return Response{
		StatusCode: NOK,
		ErrorCode:  code,
		Message:    message,
	}
}

func SuccessResponse(data interface{}) Response {
	return Response{
		StatusCode: OK,
		Response:   data,
	}
}

func WriteJsonResponse(response Response, c *gin.Context) {
	response = response.populateStatus()

	c.JSON(StatusToHttpCode(response.StatusCode, response.ErrorCode), response)
}

func WriteBinary(contentType string, b []byte, c *gin.Context) {
	c.Data(http.StatusOK, contentType, b)
}

type Middleware func(*gin.Context) *Error

func M(handler Middleware) gin.HandlerFunc {
	return func(c *gin.Context) {
		err := handler(c)

		if err != nil {
			WriteJsonResponse(ErrorResponse(err.Flag(), err.UserMessage), c)
			c.Error(err)
			c.Abort()
		} else {
			c.Next()
		}
	}
}

type Query interface {
	ValidateParams() *Error
	Run() (interface{}, *Error)
}

func RunQuery(query Query, c *gin.Context) {
	if err := query.ValidateParams(); err != nil {
		WriteJsonResponse(ErrorResponse(err.Flag(), err.UserMessage), c)
		c.Error(err)
		return
	}

	if out, err := query.Run(); err != nil {
		WriteJsonResponse(ErrorResponse(err.Flag(), err.UserMessage), c)
		c.Error(err)
	} else {
		WriteJsonResponse(SuccessResponse(out), c)
	}
}