join.go

package xerror

import (
	"encoding/json"
	"errors"
	"fmt"
	"strings"

	"github.com/gomooth/xerror/xcode"
)

// xJoinedError 合并多个 XError 的多错误类型，保留聚合的错误码信息。
// 聚合策略：取第一个非 CodeNone 的 XError 的 code/httpStatus/message。
type xJoinedError struct {
	errorBase
	errs []error
}

func (je *xJoinedError) Message() string { return je.chainMsg }

// Unwrap 返回第一个子错误，满足 XError 接口的单链遍历。
// 所有子错误可通过 Errors() 方法获取。
func (je *xJoinedError) Unwrap() error {
	if len(je.errs) > 0 {
		return je.errs[0]
	}
	return nil
}

// As 支持 errors.As 遍历所有子错误，而非仅第一个。
// 因 Go 不允许同类型同时定义 Unwrap() error 和 Unwrap() []error，
// 通过自定义 As 方法实现多错误链的完整遍历。
func (je *xJoinedError) As(target any) bool {
	for _, child := range je.errs {
		if errors.As(child, target) {
			return true
		}
	}
	return false
}

// Errors 返回所有子错误的副本，修改不影响原始错误。
func (je *xJoinedError) Errors() []error {
	if je.errs == nil {
		return nil
	}
	result := make([]error, len(je.errs))
	copy(result, je.errs)
	return result
}

func (je *xJoinedError) Is(target error) bool {
	switch t := target.(type) {
	case *xJoinedError:
		if isCodeMatch(je.ErrorCode(), t.ErrorCode()) {
			return true
		}
		if je == t {
			return true
		}
	case *xError:
		if isCodeMatch(je.ErrorCode(), t.ErrorCode()) {
			return true
		}
	}

	// 检查 target 是否为子错误（指针同一性 + 递归 Is）
	for _, child := range je.errs {
		if child == target {
			return true
		}
		if childIs, ok := child.(interface{ Is(error) bool }); ok && childIs.Is(target) {
			return true
		}
	}
	return false
}

func (je *xJoinedError) WithFields(fields ...Field) XError {
	if len(fields) == 0 {
		return je
	}
	base := appendFields(je.errorBase, fields...)
	return &xJoinedError{
		errorBase: base,
		errs:      je.errs,
	}
}

func (je *xJoinedError) WithHttpStatus(httpStatus int) XError {
	base := je.errorBase
	base.code = xcode.WithHttpStatus(base.code, httpStatus)
	return &xJoinedError{errorBase: base, errs: je.errs}
}

func (je *xJoinedError) Format(s fmt.State, verb rune) {
	switch verb {
	case 'v':
		if s.Flag('+') {
			writeFieldsToFormatState(s, je.fields)
			for _, e := range je.errs {
				_, _ = fmt.Fprintf(s, "%+v\n", e)
			}
			return
		}
		_, _ = fmt.Fprintf(s, "%s", je.Error())
	case 's':
		_, _ = fmt.Fprintf(s, "%s", je.Error())
	case 'q':
		_, _ = fmt.Fprintf(s, "%q", je.Error())
	}
}

type jsonJoinedError struct {
	Code       int             `json:"code"`
	HttpStatus int             `json:"httpStatus"`
	Message    string          `json:"message"`
	Errors     []string        `json:"errors,omitempty"`
	Fields     json.RawMessage `json:"fields,omitempty"`
}

func (je *xJoinedError) MarshalJSON() ([]byte, error) {
	jje := jsonJoinedError{
		Code:       je.ErrorCode(),
		HttpStatus: je.HttpStatus(),
		Message:    je.Message(),
	}
	if len(je.errs) > 0 {
		jje.Errors = make([]string, len(je.errs))
		for i, e := range je.errs {
			jje.Errors[i] = e.Error()
		}
	}
	fieldsJSON, err := marshalFieldsJSON(je.fields)
	if err != nil {
		return nil, err
	}
	jje.Fields = fieldsJSON
	return json.Marshal(jje)
}

// JoinXErrors 合并多个 XError 为一个多错误。
// nil 参数会被过滤。聚合策略：取第一个非 CodeNone 的 XError 的错误码信息。
func JoinXErrors(errs ...XError) XError {
	var nonNil []error
	var firstCode xcode.XCode
	var firstChainMsg string

	for _, e := range errs {
		if e != nil {
			nonNil = append(nonNil, e)
			if firstCode == nil && e.ErrorCode() != xcode.CodeNone {
				firstCode = e.XCode()
				firstChainMsg = e.ChainMessage()
			}
		}
	}

	if len(nonNil) == 0 {
		return nil
	}

	if firstCode == nil {
		firstCode = xcode.InternalServerError
	}
	if firstChainMsg == "" && len(nonNil) > 0 {
		firstChainMsg = chainMessageOf(nonNil[0])
	}

	msgs := make([]string, len(nonNil))
	for i, e := range nonNil {
		msgs[i] = e.Error()
	}
	errStr := strings.Join(msgs, "\n")

	return &xJoinedError{
		errorBase: errorBase{
			code:     firstCode,
			stack:    captureStack(1),
			chainMsg: firstChainMsg,
			errStr:   errStr,
		},
		errs: nonNil,
	}
}

// JoinErrors 合并多个 error 为一个多错误（支持混合类型）。
// 自动识别其中的 XError，聚合策略同 JoinXErrors。
func JoinErrors(errs ...error) error {
	var nonNil []error
	var firstCode xcode.XCode
	var firstChainMsg string

	for _, e := range errs {
		if e != nil {
			nonNil = append(nonNil, e)
			if firstCode == nil {
				if xe, ok := asXErrorInternal(e); ok && xe.ErrorCode() != xcode.CodeNone {
					firstCode = rawCodeOf(xe)
					firstChainMsg = xe.ChainMessage()
				}
			}
		}
	}

	if len(nonNil) == 0 {
		return nil
	}

	if firstCode == nil {
		firstCode = xcode.InternalServerError
	}
	if firstChainMsg == "" && len(nonNil) > 0 {
		firstChainMsg = chainMessageOf(nonNil[0])
	}

	msgs := make([]string, len(nonNil))
	for i, e := range nonNil {
		msgs[i] = e.Error()
	}
	errStr := strings.Join(msgs, "\n")

	return &xJoinedError{
		errorBase: errorBase{
			code:     firstCode,
			stack:    captureStack(1),
			chainMsg: firstChainMsg,
			errStr:   errStr,
		},
		errs: nonNil,
	}
}