package processors

import (
	"errors"
	"testing"
)

func TestErrorsJoin_Is(t *testing.T) {
	// 创建一个参数验证错误
	originalErr := errors.New("字段验证失败")
	joinedErr := errors.Join(ErrInvalidParam, originalErr)

	// 测试 errors.Is 是否能正确识别错误类型
	if !errors.Is(joinedErr, ErrInvalidParam) {
		t.Errorf("errors.Is(joinedErr, ErrInvalidParam) 应该返回 true")
	}

	if errors.Is(joinedErr, ErrSystem) {
		t.Errorf("errors.Is(joinedErr, ErrSystem) 应该返回 false")
	}

	// 测试错误消息
	expectedMsg := "参数校验不正确\n字段验证失败"
	if joinedErr.Error() != expectedMsg {
		t.Errorf("错误消息不匹配，期望: %s, 实际: %s", expectedMsg, joinedErr.Error())
	}
}

func TestErrorsJoin_Unwrap(t *testing.T) {
	originalErr := errors.New("原始错误")
	joinedErr := errors.Join(ErrSystem, originalErr)

	// 测试 Unwrap - errors.Join 的 Unwrap 行为
	// errors.Join 的 Unwrap 可能返回 nil 或者第一个错误，这取决于实现
	// 我们主要关心 errors.Is 是否能正确工作
	if !errors.Is(joinedErr, ErrSystem) {
		t.Errorf("errors.Is(joinedErr, ErrSystem) 应该返回 true")
	}
}

func TestErrorsJoin_MultipleErrors(t *testing.T) {
	err1 := errors.New("错误1")
	err2 := errors.New("错误2")
	joinedErr := errors.Join(ErrNotFound, err1, err2)

	// 测试 errors.Is 识别多个错误类型
	if !errors.Is(joinedErr, ErrNotFound) {
		t.Errorf("errors.Is(joinedErr, ErrNotFound) 应该返回 true")
	}

	// 测试错误消息
	expectedMsg := "查询为空\n错误1\n错误2"
	if joinedErr.Error() != expectedMsg {
		t.Errorf("错误消息不匹配，期望: %s, 实际: %s", expectedMsg, joinedErr.Error())
	}
}

func TestErrorsJoin_RealWorldScenario(t *testing.T) {
	// 模拟真实的处理器错误场景
	validationErr := errors.New("手机号格式不正确")
	processorErr := errors.Join(ErrInvalidParam, validationErr)

	// 在应用服务层，现在应该可以正确识别错误类型
	if !errors.Is(processorErr, ErrInvalidParam) {
		t.Errorf("应用服务层应该能够识别 ErrInvalidParam")
	}

	// 错误消息应该包含两种信息
	errorMsg := processorErr.Error()
	if !contains(errorMsg, "参数校验不正确") {
		t.Errorf("错误消息应该包含错误类型: %s", errorMsg)
	}
	if !contains(errorMsg, "手机号格式不正确") {
		t.Errorf("错误消息应该包含原始错误: %s", errorMsg)
	}
}

// 辅助函数：检查字符串是否包含子字符串
func contains(s, substr string) bool {
	return len(s) >= len(substr) && (s == substr || 
		(len(s) > len(substr) && (s[:len(substr)] == substr || 
		s[len(s)-len(substr):] == substr || 
		func() bool {
			for i := 1; i <= len(s)-len(substr); i++ {
				if s[i:i+len(substr)] == substr {
					return true
				}
			}
			return false
		}())))
}