package message

import (
	"fmt"

	"github.com/pkg/errors"
)

type Error struct {
	Code int           `json:"-"`
	Msg  string        `json:"msg"`
	Args []interface{} `json:"-"`
}

func NewMessageError(message string) Error {
	return Error{
		Msg: message,
	}
}

func NewBaseError(code int, message string, args ...interface{}) *Error {
	return &Error{
		Code: code,
		Msg:  message,
		Args: args,
	}
}

func NewError(code int, message, userMsg string) Error {
	return Error{
		Code: code,
		Msg:  message,
	}
}

func (err Error) Error() string {
	return err.Msg
}

func (err Error) WithArgs(args ...interface{}) Error {
	err.Args = args
	return err
}

func (err Error) Sprintf(v ...interface{}) Error {
	err.Msg = fmt.Sprintf(err.Msg+": %v", v...)
	return err
}

func (err Error) Equal(e error) bool {
	switch errors.Cause(e).(type) {
	case Error:
		return err.Code == errors.Cause(e).(Error).Code
	default:
		return false
	}
}

func (err Error) WrapPrint(core error, message string, user ...interface{}) error {
	if core == nil {
		return nil
	}
	ret := err
	SetErrPrintfMsg(&ret, core)
	return errors.Wrap(ret, message)
}

func (err Error) WrapPrintf(core error, format string, message ...interface{}) error {
	if core == nil {
		return nil
	}
	ret := err
	SetErrPrintfMsg(&ret, core)
	return errors.Wrap(ret, fmt.Sprintf(format, message...))
}

func (err Error) Wrap(core error) error {
	if core == nil {
		return nil
	}

	msg := err.Msg
	err.Msg = core.Error()
	return errors.Wrap(err, msg)
}

func SetErrPrintfMsg(err *Error, v ...interface{}) {
	err.Msg = fmt.Sprintf(err.Msg+": %v", v...)
}