package myerrors

import (
	"context"
	"github.com/gogf/gf/errors/gerror"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gconv"
	"github.com/smallnest/rpcx/protocol"
	"strings"
)

const (
	_ = 1000 + iota
	TipsErr
	ValidErr
	QueryErr
	CreateErr
	UpdateErr
	DeleteErr

	AuthErr      = 1010
	PermErr      = 1011
	MicroCallErr = 1100
	ConvErr      = 1200
	DbErr        = 1201
	SysErr       = 500
)

var ErrorTips = g.MapIntStr{
	TipsErr:   "错误提示",
	ValidErr:  "数据校验失败",
	QueryErr:  "%s查询失败",
	CreateErr: "%s创建失败",
	UpdateErr: "%s更新失败",
	DeleteErr: "%s删除失败",

	AuthErr:      "登录失效或认证失败，请重新尝试",
	PermErr:      "权限验证失败，请重新尝试",
	MicroCallErr: "微服务调用失败，请重新尝试",

	ConvErr: "数据转换异常，请重新尝试",
	DbErr:   "数据库操作异常，请重新尝试",
	SysErr:  "系统异常，请重新尝试",
}

func New(errCode int, err error, errMsg ...string) error {
	if err == nil {
		return gerror.NewCode(errCode, handleErrMsg(ConvErr, errMsg...))
	}
	return gerror.WrapCode(errCode, err, handleErrMsg(ConvErr, errMsg...))
}
func TipsError(errMsg string) error {
	return gerror.NewCode(TipsErr, errMsg)
}
func ValidError(errMsg ...string) error {
	return gerror.NewCode(ValidErr, handleErrMsg(ConvErr, errMsg...))
}
func QueryError(err error, module string) error {
	return gerror.WrapCodef(QueryErr, err, ErrorTips[QueryErr], module)
}
func CreateError(err error, module string) error {
	return gerror.WrapCodef(CreateErr, err, ErrorTips[CreateErr], module)
}
func UpdateError(err error, module string) error {
	return gerror.WrapCodef(UpdateErr, err, ErrorTips[UpdateErr], module)
}
func DeleteError(err error, module string) error {
	return gerror.WrapCodef(DeleteErr, err, ErrorTips[DeleteErr], module)
}
func AuthError(errMsg ...string) error {
	return gerror.NewCode(AuthErr, handleErrMsg(ConvErr, errMsg...))
}
func PermError(errMsg ...string) error {
	return gerror.NewCode(PermErr, handleErrMsg(ConvErr, errMsg...))
}
func MicroCallError(errMsg ...string) error {
	return gerror.NewCode(MicroCallErr, handleErrMsg(ConvErr, errMsg...))
}
func ConvError(errMsg ...string) error {
	return gerror.NewCode(ConvErr, handleErrMsg(ConvErr, errMsg...))
}
func DbError(errMsg ...string) error {
	return gerror.NewCode(DbErr, handleErrMsg(DbErr, errMsg...))
}
func SysError() error {
	return gerror.NewCode(SysErr, ErrorTips[SysErr])
}

func handleErrMsg(errCode int, errMsg ...string) string {
	msg, ok := ErrorTips[errCode]
	if ok && len(errMsg) > 0 {
		msg = ErrorTips[errCode] + ": " + strings.Join(errMsg, ", ")
	}
	return msg
}

type HandleErrorPlugin struct{}

func (p HandleErrorPlugin) PreWriteResponse(ctx context.Context, req *protocol.Message, res *protocol.Message, err error) error {
	if err == nil {
		// todo 正常数据处理
		resData := gconv.Map(res.Payload)
		resData["code"] = 200
		if val, ok := resData["msg"]; ok && val != "" {
		} else {
			resData["msg"] = "操作成功"
		}
		res.Payload = gconv.Bytes(gconv.String(resData))
		return nil
	}
	// error 堆栈信息输出
	g.Log().Error(gerror.Stack(err))

	if gErr, ok := err.(*gerror.Error); ok {
		var resData = g.Map{}
		// 检查是否存在二级错误，如存在取底层错误信息
		gNextError := gerror.Next(gErr)
		nextErrFlag := false
		if gNextError != nil {
			if err, ok := gNextError.(*gerror.Error); ok {
				gErr = err
				nextErrFlag = true
			}
		}
		code := gerror.Code(gErr)
		if code > 1000 {
			// 业务级异常处理
			resData = g.Map{
				"code": code,
				"msg":  err,
			}
		} else {
			// 系统级异常处理
			resData = g.Map{
				"code": SysErr,
				"msg":  ErrorTips[SysErr],
			}
			// 检查是否存在业务信息，添加显示
			code := gerror.Code(err)
			if nextErrFlag && code > 1000 {
				resData = g.Map{
					"code": code,
					"msg":  splitErrorStr(err.Error()),
				}
			}
		}
		res.Payload = gconv.Bytes(gconv.String(resData))
		res.SetMessageStatusType(protocol.Normal)
		if res.Metadata != nil {
			delete(res.Metadata, protocol.ServiceError)
		}
	}

	return nil
}

func splitErrorStr(errMsg string) string {
	errStrIndex := strings.Index(errMsg, ": ")
	return errMsg[:errStrIndex] + ": " + ErrorTips[SysErr]
}