tydata-server/app/user/cmd/api/internal/service/apirequestService.go

package service

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"sort"
	"strings"
	"sync"
	"sync/atomic"
	"time"
	"tydata-server/app/user/cmd/api/internal/config"
	"tydata-server/app/user/model"
	"tydata-server/pkg/lzkit/crypto"
	"tydata-server/pkg/lzkit/lzUtils"

	"github.com/Masterminds/squirrel"
	"github.com/bytedance/sonic"
	"github.com/tidwall/gjson"
	"github.com/zeromicro/go-zero/core/logx"
)

type ApiRequestService struct {
	config              config.Config
	westDexService      *WestDexService
	yushanService       *YushanService
	featureModel        model.FeatureModel
	productFeatureModel model.ProductFeatureModel
}

// NewApiRequestService 是一个构造函数，用于初始化 ApiRequestService
func NewApiRequestService(c config.Config, westDexService *WestDexService, yushanService *YushanService, featureModel model.FeatureModel, productFeatureModel model.ProductFeatureModel) *ApiRequestService {
	return &ApiRequestService{
		config:              c,
		featureModel:        featureModel,
		productFeatureModel: productFeatureModel,
		westDexService:      westDexService,
		yushanService:       yushanService,
	}
}

type APIResponseData struct {
	ApiID     string          `json:"apiID"`
	Data      json.RawMessage `json:"data"` // 这里用 RawMessage 来存储原始的 data
	Success   bool            `json:"success"`
	Timestamp string          `json:"timestamp"`
	Error     string          `json:"error,omitempty"`
}

// ProcessRequests 处理请求
func (a *ApiRequestService) ProcessRequests(params []byte, productID int64) ([]byte, error) {
	var ctx, cancel = context.WithCancel(context.Background())
	defer cancel()
	build := a.productFeatureModel.SelectBuilder().Where(squirrel.Eq{
		"product_id": productID,
	})
	productFeatureList, findProductFeatureErr := a.productFeatureModel.FindAll(ctx, build, "")
	if findProductFeatureErr != nil {
		return nil, findProductFeatureErr
	}
	var featureIDs []int64
	isImportantMap := make(map[int64]int64, len(productFeatureList))
	for _, pf := range productFeatureList {
		featureIDs = append(featureIDs, pf.FeatureId)
		isImportantMap[pf.FeatureId] = pf.IsImportant
	}
	if len(featureIDs) == 0 {
		return nil, errors.New("featureIDs 是空的")
	}
	builder := a.featureModel.SelectBuilder().Where(squirrel.Eq{"id": featureIDs})
	featureList, findFeatureErr := a.featureModel.FindAll(ctx, builder, "")
	if findFeatureErr != nil {
		return nil, findFeatureErr
	}
	if len(featureList) == 0 {
		return nil, errors.New("处理请求错误，产品无对应接口功能")
	}
	var (
		wg         sync.WaitGroup
		resultsCh  = make(chan APIResponseData, len(featureList))
		errorsCh   = make(chan error, len(featureList))
		errorCount int32
		errorLimit = len(featureList)
		retryNum   = 5
	)

	for i, feature := range featureList {
		wg.Add(1)
		go func(i int, feature *model.Feature) {
			defer wg.Done()

			select {
			case <-ctx.Done():
				return
			default:
			}
			result := APIResponseData{
				ApiID:   feature.ApiId,
				Success: false,
			}
			timestamp := time.Now().Format("2006-01-02 15:04:05")
			var (
				resp          json.RawMessage
				preprocessErr error
			)
			// 若 isImportantMap[feature.ID] == 1，则表示需要在出错时重试
			isImportant := isImportantMap[feature.Id] == 1
			tryCount := 0
			for {
				tryCount++
				resp, preprocessErr = a.PreprocessRequestApi(params, feature.ApiId)
				if preprocessErr == nil {
					break
				}
				if isImportant && tryCount < retryNum {
					continue
				} else {
					break
				}
			}
			if preprocessErr != nil {
				result.Timestamp = timestamp
				result.Error = preprocessErr.Error()
				result.Data = resp
				resultsCh <- result
				errorsCh <- fmt.Errorf("请求失败: %v", preprocessErr)
				atomic.AddInt32(&errorCount, 1)
				if atomic.LoadInt32(&errorCount) >= int32(errorLimit) {
					cancel()
				}
				return
			}

			result.Data = resp
			result.Success = true
			result.Timestamp = timestamp
			resultsCh <- result
		}(i, feature)
	}

	go func() {
		wg.Wait()
		close(resultsCh)
		close(errorsCh)
	}()
	// 收集所有结果并合并z
	var responseData []APIResponseData
	for result := range resultsCh {
		responseData = append(responseData, result)
	}
	if atomic.LoadInt32(&errorCount) >= int32(errorLimit) {
		var allErrors []error
		for err := range errorsCh {
			allErrors = append(allErrors, err)
		}
		return nil, fmt.Errorf("请求失败次数超过 %d 次: %v", errorLimit, allErrors)
	}

	combinedResponse, err := json.Marshal(responseData)
	if err != nil {
		return nil, fmt.Errorf("响应数据转 JSON 失败: %v", err)
	}

	return combinedResponse, nil
}

// ------------------------------------请求处理器--------------------------
var requestProcessors = map[string]func(*ApiRequestService, []byte) ([]byte, error){
	"G09SC02":      (*ApiRequestService).ProcessG09SC02Request,
	"G27BJ05":      (*ApiRequestService).ProcessG27BJ05Request,
	"G26BJ05":      (*ApiRequestService).ProcessG26BJ05Request,
	"G34BJ03":      (*ApiRequestService).ProcessG34BJ03Request,
	"G35SC01":      (*ApiRequestService).ProcessG35SC01Request,
	"G28BJ05":      (*ApiRequestService).ProcessG28BJ05Request,
	"G05HZ01":      (*ApiRequestService).ProcessG05HZ01Request,
	"Q23SC01":      (*ApiRequestService).ProcessQ23SC01Request,
	"G15BJ02":      (*ApiRequestService).ProcessG15BJ02Request,
	"G17BJ02":      (*ApiRequestService).ProcessG17BJ02Request,
	"G08SC02":      (*ApiRequestService).ProcessG08SC02Request,
	"KZEYS":        (*ApiRequestService).ProcessKZEYSRequest,
	"P_C_B332":     (*ApiRequestService).ProcessP_C_B332Request,
	"FIN019":       (*ApiRequestService).ProcessFIN019Request,
	"CAR061":       (*ApiRequestService).ProcessCAR061Request,
	"IDV044":       (*ApiRequestService).ProcessIDV044Request,
	"G10SC02":      (*ApiRequestService).ProcessG10SC02Request,
	"G03HZ01":      (*ApiRequestService).ProcessG03HZ01Request,
	"G02BJ02":      (*ApiRequestService).ProcessG02BJ02Request,
	"G19BJ02":      (*ApiRequestService).ProcessG19BJ02Request,
	"G20GZ01":      (*ApiRequestService).ProcessG20GZ01Request,
	"G37SC01":      (*ApiRequestService).ProcessG37SC01Request,
	"G36SC01":      (*ApiRequestService).ProcessG36SC01Request,
	"G22SC01":      (*ApiRequestService).ProcessG22SC01Request,
	"Q03SC01":      (*ApiRequestService).ProcessQ03SC01Request,
	"G39SC02":      (*ApiRequestService).ProcessG39SC02Request,
	"G38SC02":      (*ApiRequestService).ProcessG38SC02Request,
	"layoutIdcard": (*ApiRequestService).ProcessLayoutIdcardRequest,

	// New Feature
	"PersonEnterprisePro": (*ApiRequestService).ProcessPersonEnterpriseProRequest,
	"BehaviorRiskScan":    (*ApiRequestService).ProcessBehaviorRiskScanRequest,
	"G30BJ05":             (*ApiRequestService).ProcessG30BJ05Request,
	"G31BJ05":             (*ApiRequestService).ProcessG31BJ05Request,
	"G32BJ05":             (*ApiRequestService).ProcessG32BJ05Request,
	"RIS031":              (*ApiRequestService).ProcessRIS031Request,
	"G09XM02":             (*ApiRequestService).ProcessG09XM02Request,
	"G10XM02":             (*ApiRequestService).ProcessG10XM02Request,
	"G11BJ06":             (*ApiRequestService).ProcessG11BJ06Request,
}

// PreprocessRequestApi 调用指定的请求处理函数
func (a *ApiRequestService) PreprocessRequestApi(params []byte, apiID string) ([]byte, error) {
	if processor, exists := requestProcessors[apiID]; exists {
		return processor(a, params) // 调用 ApiRequestService 方法
	}

	return nil, errors.New("api请求, 未找到相应的处理程序")
}

func (a *ApiRequestService) ProcessG09SC02Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, G09SC02, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"certNumMan": a.westDexService.Encrypt(idCard.String()),
			"nameMan":    a.westDexService.Encrypt(name.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G09SC02", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	result := gjson.GetBytes(resp, "data.0.maritalStatus")

	if result.Exists() {
		responseMap := map[string]string{"status": result.String()}
		jsonResponse, err := json.Marshal(responseMap)
		if err != nil {
			return nil, err
		}
		return jsonResponse, nil
	} else {
		return nil, errors.New("查询为空")
	}
}

func (a *ApiRequestService) ProcessG27BJ05Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	mobile := gjson.GetBytes(params, "mobile")

	if !name.Exists() || !idCard.Exists() || !mobile.Exists() {
		return nil, errors.New("api请求, G27BJ05, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"id":   a.westDexService.Encrypt(idCard.String()),
			"name": a.westDexService.Encrypt(name.String()),
			"cell": a.westDexService.Encrypt(mobile.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G27BJ05", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 获取 code 字段
	codeResult := gjson.GetBytes(resp, "code")
	if !codeResult.Exists() {
		return nil, fmt.Errorf("code 字段不存在")
	}
	if codeResult.String() != "00" {
		return nil, fmt.Errorf("未匹配到相关结果")
	}

	// 获取 data 字段
	dataResult := gjson.GetBytes(resp, "data")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("data 字段不存在")
	}

	// 将 data 字段解析为 map
	var dataMap map[string]interface{}
	if err := json.Unmarshal([]byte(dataResult.Raw), &dataMap); err != nil {
		return nil, fmt.Errorf("解析 data 字段失败: %v", err)
	}

	// 删除指定字段
	delete(dataMap, "swift_number")
	delete(dataMap, "DataStrategy")

	// 重新编码为 JSON
	modifiedData, err := json.Marshal(dataMap)
	if err != nil {
		return nil, fmt.Errorf("编码修改后的 data 失败: %v", err)
	}
	return modifiedData, nil
}

func (a *ApiRequestService) ProcessG26BJ05Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	mobile := gjson.GetBytes(params, "mobile")

	if !name.Exists() || !idCard.Exists() || !mobile.Exists() {
		return nil, errors.New("api请求, G26BJ05, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"id":         a.westDexService.Encrypt(idCard.String()),
			"name":       a.westDexService.Encrypt(name.String()),
			"cell":       a.westDexService.Encrypt(mobile.String()),
			"time_range": 5,
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G26BJ05", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	codeResult := gjson.GetBytes(resp, "code")
	if !codeResult.Exists() {
		return nil, fmt.Errorf("code 字段不存在")
	}
	if codeResult.String() != "00" {
		return nil, fmt.Errorf("未匹配到相关结果")
	}

	// 获取 data 字段
	dataResult := gjson.GetBytes(resp, "data")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("data 字段不存在")
	}

	// 将 data 字段解析为 map
	var dataMap map[string]interface{}
	if err := json.Unmarshal([]byte(dataResult.Raw), &dataMap); err != nil {
		return nil, fmt.Errorf("解析 data 字段失败: %v", err)
	}

	// 删除指定字段
	delete(dataMap, "swift_number")
	delete(dataMap, "DataStrategy")

	// 重新编码为 JSON
	modifiedData, err := json.Marshal(dataMap)
	if err != nil {
		return nil, fmt.Errorf("编码修改后的 data 失败: %v", err)
	}
	return modifiedData, nil
}

func (a *ApiRequestService) ProcessG34BJ03Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, G34BJ03, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"id_card": a.westDexService.Encrypt(idCard.String()),
			"name":    a.westDexService.Encrypt(name.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G34BJ03", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	dataResult := gjson.GetBytes(resp, "negative_info.data.risk_level")
	if dataResult.Exists() {
		// 如果字段存在，构造包含 "status" 的 JSON 响应
		responseMap := map[string]string{"risk_level": dataResult.String()}
		jsonResponse, err := json.Marshal(responseMap)
		if err != nil {
			return nil, err
		}
		return jsonResponse, nil
	} else {
		return nil, errors.New("查询为空")
	}
}

func (a *ApiRequestService) ProcessG35SC01Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, G35SC01, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"idcard":        a.westDexService.Encrypt(idCard.String()),
			"name":          a.westDexService.Encrypt(name.String()),
			"inquired_auth": a.westDexService.GetDateRange(),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G35SC01", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 第一步：提取外层的 data 字段
	dataResult := gjson.GetBytes(resp, "data")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("外层 data 字段不存在")
	}

	// 第二步：解析外层 data 的 JSON 字符串
	var outerDataMap map[string]interface{}
	if err := json.Unmarshal([]byte(dataResult.String()), &outerDataMap); err != nil {
		return nil, fmt.Errorf("解析外层 data 字段失败: %v", err)
	}

	// 第三步：提取内层的 data 字段
	innerData, ok := outerDataMap["data"].(string)
	if !ok {
		return nil, fmt.Errorf("内层 data 字段不存在或类型错误")
	}

	if innerData == "" || innerData == "{}" || innerData == "[]" {
		innerData = "{}"
	}

	// 第四步：解析内层 data 的 JSON 字符串
	var finalDataMap map[string]interface{}
	if err := json.Unmarshal([]byte(innerData), &finalDataMap); err != nil {
		return nil, fmt.Errorf("解析内层 data 字段失败: %v", err)
	}

	finalDataBytes, err := json.Marshal(finalDataMap)
	if err != nil {
		return nil, fmt.Errorf("编码最终的 JSON 对象失败: %v", err)
	}

	return finalDataBytes, nil
}

func (a *ApiRequestService) ProcessG28BJ05Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	mobile := gjson.GetBytes(params, "mobile")

	if !name.Exists() || !idCard.Exists() || !mobile.Exists() {
		return nil, errors.New("api请求, G28BJ05, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"id":   a.westDexService.Encrypt(idCard.String()),
			"name": a.westDexService.Encrypt(name.String()),
			"cell": a.westDexService.Encrypt(mobile.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G28BJ05", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 获取 code 字段
	codeResult := gjson.GetBytes(resp, "code")
	if !codeResult.Exists() {
		return nil, fmt.Errorf("code 字段不存在")
	}
	if codeResult.String() != "00" {
		return nil, fmt.Errorf("未匹配到相关结果")
	}

	// 获取 data 字段
	dataResult := gjson.GetBytes(resp, "data")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("data 字段不存在")
	}

	// 将 data 字段解析为 map
	var dataMap map[string]interface{}
	if err := json.Unmarshal([]byte(dataResult.Raw), &dataMap); err != nil {
		return nil, fmt.Errorf("解析 data 字段失败: %v", err)
	}

	// 删除指定字段
	delete(dataMap, "swift_number")
	delete(dataMap, "DataStrategy")

	// 重新编码为 JSON
	modifiedData, err := json.Marshal(dataMap)
	if err != nil {
		return nil, fmt.Errorf("编码修改后的 data 失败: %v", err)
	}
	return modifiedData, nil
}

func (a *ApiRequestService) ProcessG05HZ01Request(params []byte) ([]byte, error) {
	idCard := gjson.GetBytes(params, "id_card")

	if !idCard.Exists() {
		return nil, errors.New("api请求, G05HZ01, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"pid": crypto.Md5Encrypt(idCard.String()),
	}
	resp, callApiErr := a.westDexService.G05HZ01CallAPI("G05HZ01", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 处理股东人企关系的响应数据
	code := gjson.GetBytes(resp, "code")
	if !code.Exists() {
		return nil, fmt.Errorf("响应中缺少 code 字段")
	}

	// 判断 code 是否等于 "0000"
	if code.String() == "0000" {
		// 获取 data 字段的值
		data := gjson.GetBytes(resp, "data")
		if !data.Exists() {
			return nil, fmt.Errorf("响应中缺少 data 字段")
		}
		// 返回 data 字段的内容
		return []byte(data.Raw), nil
	}

	// code 不等于 "0000"，返回错误
	return nil, fmt.Errorf("响应code错误%s", code.String())
}
func (a *ApiRequestService) ProcessQ23SC01Request(params []byte) ([]byte, error) {
	entName := gjson.GetBytes(params, "ent_name")
	entCode := gjson.GetBytes(params, "ent_code")

	if !entName.Exists() || !entCode.Exists() {
		return nil, errors.New("api请求, Q23SC01, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"uscc":          a.westDexService.Encrypt(entCode.String()),
			"org_name":      a.westDexService.Encrypt(entName.String()),
			"inquired_auth": a.westDexService.GetDateRange(),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("Q23SC01", request)
	logx.Infof("企业涉诉返回%+v", string(resp))
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 第一步：提取外层的 data 字段
	dataResult := gjson.GetBytes(resp, "data")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("外层 data 字段不存在")
	}

	// 第二步：解析外层 data 的 JSON 字符串
	var outerDataMap map[string]interface{}
	if err := json.Unmarshal([]byte(dataResult.String()), &outerDataMap); err != nil {
		return nil, fmt.Errorf("解析外层 data 字段失败: %v", err)
	}

	// 第三步：提取内层的 data 字段
	innerData, ok := outerDataMap["data"].(string)
	if !ok {
		return nil, fmt.Errorf("内层 data 字段不存在或类型错误")
	}

	// 第四步：解析内层 data 的 JSON 字符串
	var finalDataMap map[string]interface{}
	if err := json.Unmarshal([]byte(innerData), &finalDataMap); err != nil {
		return nil, fmt.Errorf("解析内层 data 字段失败: %v", err)
	}

	// 将最终的 JSON 对象编码为字节数组返回
	finalDataBytes, err := json.Marshal(finalDataMap)
	if err != nil {
		return nil, fmt.Errorf("编码最终的 JSON 对象失败: %v", err)
	}

	statusResult := gjson.GetBytes(finalDataBytes, "status.status")
	if statusResult.Exists() || statusResult.Int() == -1 {
		return nil, fmt.Errorf("企业涉诉为空: %+v", finalDataBytes)
	}
	return finalDataBytes, nil
}

func (a *ApiRequestService) ProcessG15BJ02Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	mobile := gjson.GetBytes(params, "mobile")

	if !name.Exists() || !idCard.Exists() || !mobile.Exists() {
		return nil, errors.New("api请求, G15BJ02, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name":  a.westDexService.Encrypt(name.String()),
			"idNo":  a.westDexService.Encrypt(idCard.String()),
			"phone": a.westDexService.Encrypt(mobile.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G15BJ02", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	dataResult := gjson.GetBytes(resp, "data.code")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("code 字段不存在")
	}
	code := dataResult.Int()
	// 处理允许的 code 值
	if code == 1000 || code == 1003 || code == 1004 || code == 1005 {
		return resp, nil
	}

	return nil, fmt.Errorf("三要素核验失败: %+v", resp)
}

func (a *ApiRequestService) ProcessG17BJ02Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	mobile := gjson.GetBytes(params, "mobile")

	if !name.Exists() || !mobile.Exists() {
		return nil, errors.New("api请求, G17BJ02, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name":  a.westDexService.Encrypt(name.String()),
			"phone": a.westDexService.Encrypt(mobile.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G17BJ02", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	dataResult := gjson.GetBytes(resp, "data.code")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("code 字段不存在")
	}
	code := dataResult.Int()
	// 处理允许的 code 值
	if code == 1000 || code == 1001 {
		return resp, nil
	}

	return nil, fmt.Errorf("手机二要素核验失败: %+v", resp)
}

func (a *ApiRequestService) ProcessG08SC02Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, G08SC02, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"xm":      a.westDexService.Encrypt(name.String()),
			"gmsfzhm": a.westDexService.Encrypt(idCard.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G08SC02", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	return resp, nil
}

func (a *ApiRequestService) ProcessKZEYSRequest(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, KZEYS, 获取相关参数失败")
	}

	appCode := a.config.Ali.Code
	requestUrl := "https://kzidcardv1.market.alicloudapi.com/api-mall/api/id_card/check"

	// 构造查询参数
	data := url.Values{}
	data.Add("name", name.String())
	data.Add("idcard", idCard.String())

	req, err := http.NewRequest(http.MethodPost, requestUrl, strings.NewReader(data.Encode()))
	if err != nil {
		return nil, fmt.Errorf("KZEYS 创建请求失败: %v", err)
	}
	req.Header.Set("Authorization", "APPCODE "+appCode)
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("KZEYS 请求失败: %v", err)
	}

	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("KZEYS 请求失败, 状态码: %d", resp.StatusCode)
	}
	respBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("KZEYS 响应体读取失败:%v", err)
	}
	// 使用 gjson 解析 JSON 数据
	code := gjson.GetBytes(respBody, "code").Int()
	if code != 200 {
		msg := gjson.GetBytes(respBody, "msg").String()
		if msg == "" {
			msg = "未知错误"
		}
		return nil, fmt.Errorf("KZEYS 响应失败: %s", msg)
	}

	respData := gjson.GetBytes(respBody, "data")
	if !respData.Exists() {
		return nil, fmt.Errorf("KZEYS 响应, data 字段不存在")
	}
	dataRaw := respData.Raw
	// 成功返回
	return []byte(dataRaw), nil
}

// 人车核验
func (a *ApiRequestService) ProcessP_C_B332Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	carType := gjson.GetBytes(params, "car_type")
	carLicense := gjson.GetBytes(params, "car_license")
	if !name.Exists() || !carType.Exists() || !carLicense.Exists() {
		return nil, errors.New("api请求, P_C_B332, 获取相关参数失败: car_number")
	}

	request := map[string]interface{}{
		"name":      name.String(),
		"carType":   carType.String(),
		"carNumber": carLicense.String(),
	}
	resp, err := a.yushanService.request("P_C_B332", request)
	if err != nil {
		return nil, fmt.Errorf("人车核验查询失败: %v", err)
	}
	return resp, nil
}

// 银行卡黑名单
func (a *ApiRequestService) ProcessFIN019Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	mobile := gjson.GetBytes(params, "mobile")
	bankCard := gjson.GetBytes(params, "bank_card")
	if !name.Exists() || !idCard.Exists() || !mobile.Exists() || !bankCard.Exists() {
		return nil, errors.New("api请求, FIN019, 获取相关参数失败: car_number")
	}

	request := map[string]interface{}{
		"name":   name.String(),
		"cardNo": idCard.String(),
		"mobile": mobile.String(),
		"cardld": bankCard.String(),
	}
	resp, err := a.yushanService.request("FIN019", request)
	if err != nil {
		return nil, fmt.Errorf("银行卡黑名单查询失败: %v", err)
	}
	return resp, nil
}

// 名下车辆
func (a *ApiRequestService) ProcessCAR061Request(params []byte) ([]byte, error) {
	idCard := gjson.GetBytes(params, "id_card")

	if !idCard.Exists() {
		return nil, errors.New("api请求, CAR061, 获取相关参数失败")
	}
	request := map[string]interface{}{
		"cardNo": idCard.String(),
	}
	resp, err := a.yushanService.request("CAR061", request)
	if err != nil {
		return nil, fmt.Errorf("名下车辆查询失败: %v", err)
	}
	return resp, nil
}

func (a *ApiRequestService) ProcessIDV044Request(params []byte) ([]byte, error) {
	idCard := gjson.GetBytes(params, "id_card")
	name := gjson.GetBytes(params, "name")
	if !idCard.Exists() || !name.Exists() {
		return nil, errors.New("api请求, IDV044, 获取相关参数失败")
	}
	request := map[string]interface{}{
		"cardNo": idCard.String(),
		"name":   name.String(),
	}
	resp, err := a.yushanService.request("IDV044", request)
	if err != nil {
		return nil, fmt.Errorf("婚姻状态查询失败: %v", err)
	}
	return resp, nil
}

func (a *ApiRequestService) ProcessG10SC02Request(params []byte) ([]byte, error) {
	// 提取男方和女方信息
	nameMan := gjson.GetBytes(params, "nameMan")
	idCardMan := gjson.GetBytes(params, "idCardMan")
	nameWoman := gjson.GetBytes(params, "nameWoman")
	idCardWoman := gjson.GetBytes(params, "idCardWoman")

	// 校验是否存在必要参数
	if !nameMan.Exists() || !idCardMan.Exists() || !nameWoman.Exists() || !idCardWoman.Exists() {
		return nil, errors.New("请求参数缺失：需要提供男方和女方的姓名及身份证号")
	}

	// 构造请求数据
	request := map[string]interface{}{
		"data": map[string]interface{}{
			"certNumMan":   a.westDexService.Encrypt(idCardMan.String()),
			"nameMan":      a.westDexService.Encrypt(nameMan.String()),
			"certNumWoman": a.westDexService.Encrypt(idCardWoman.String()),
			"nameWoman":    a.westDexService.Encrypt(nameWoman.String()),
		},
	}

	// 调用 API
	resp, callApiErr := a.westDexService.CallAPI("G10SC02", request)
	if callApiErr != nil {
		return nil, callApiErr
	}

	// 解析响应数据
	code := gjson.GetBytes(resp, "code").String()

	// 状态码校验
	if code != "200" {
		return nil, fmt.Errorf("婚姻查询失败：%s", string(resp))
	}

	result := gjson.GetBytes(resp, "data.0.maritalStatus")

	if result.Exists() {
		responseMap := map[string]string{"status": result.String()}
		jsonResponse, err := json.Marshal(responseMap)
		if err != nil {
			return nil, err
		}
		return jsonResponse, nil
	} else {
		return nil, errors.New("查询为空")
	}
}

// 手机号码风险
func (a *ApiRequestService) ProcessG03HZ01Request(params []byte) ([]byte, error) {
	mobile := gjson.GetBytes(params, "mobile")

	if !mobile.Exists() {
		return nil, errors.New("api请求, G03HZ01, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"mobile": a.westDexService.Encrypt(mobile.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G03HZ01", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 获取 code 字段
	codeResult := gjson.GetBytes(resp, "code")
	if !codeResult.Exists() || codeResult.String() != "0000" {
		return nil, fmt.Errorf("查询手机号码风险失败, %s", string(resp))
	}
	data := gjson.GetBytes(resp, "data.data")
	if !data.Exists() {
		return nil, fmt.Errorf("查询手机号码风险失败, %s", string(resp))
	}
	return []byte(data.Raw), nil
}

// 手机在网时长
func (a *ApiRequestService) ProcessG02BJ02Request(params []byte) ([]byte, error) {
	mobile := gjson.GetBytes(params, "mobile")

	if !mobile.Exists() {
		return nil, errors.New("api请求, G02BJ02, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"phone": a.westDexService.Encrypt(mobile.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G02BJ02", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 获取 code 字段
	codeResult := gjson.GetBytes(resp, "code")
	validCodes := map[string]bool{"1006": true, "1007": true, "1008": true, "1009": true, "1010": true}
	if !validCodes[codeResult.String()] {
		return nil, fmt.Errorf("查询手机在网时长失败, %s", string(resp))
	}
	data := gjson.GetBytes(resp, "data")
	if !data.Exists() {
		return nil, fmt.Errorf("查询手机在网时长失败, %s", string(resp))
	}
	return []byte(data.Raw), nil
}

// 手机二次卡
func (a *ApiRequestService) ProcessG19BJ02Request(params []byte) ([]byte, error) {
	mobile := gjson.GetBytes(params, "mobile")
	startDate := gjson.GetBytes(params, "startDate")
	if !mobile.Exists() {
		return nil, errors.New("api请求, G19BJ02, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"phone":     a.westDexService.Encrypt(mobile.String()),
			"startDate": startDate.String(),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G19BJ02", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 获取 code 字段
	codeResult := gjson.GetBytes(resp, "code")
	if !codeResult.Exists() || (codeResult.String() != "1025" && codeResult.String() != "1026") {
		return nil, fmt.Errorf("手机二次卡失败, %s", string(resp))
	}
	data := gjson.GetBytes(resp, "data")
	if !data.Exists() {
		return nil, fmt.Errorf("手机二次卡失败, %s", string(resp))
	}
	return []byte(data.Raw), nil
}

// 银行卡四要素
func (a *ApiRequestService) ProcessG20GZ01Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	mobile := gjson.GetBytes(params, "mobile")
	bankCard := gjson.GetBytes(params, "bank_card")

	if !mobile.Exists() {
		return nil, errors.New("api请求, G20GZ01, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name":   a.westDexService.Encrypt(name.String()),
			"idcard": a.westDexService.Encrypt(idCard.String()),
			"acc_no": a.westDexService.Encrypt(bankCard.String()),
			"mobile": a.westDexService.Encrypt(mobile.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G20GZ01", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 获取 code 字段
	codeResult := gjson.GetBytes(resp, "code")
	if !codeResult.Exists() || codeResult.String() != "10000" {
		return nil, fmt.Errorf("银行卡四要素失败, %s", string(resp))
	}
	data := gjson.GetBytes(resp, "data")
	if !data.Exists() {
		return nil, fmt.Errorf("银行卡四要素失败, %s", string(resp))
	}
	// 解析 data.Raw 字符串为接口类型
	var parsedData interface{}
	err := json.Unmarshal([]byte(data.String()), &parsedData)
	if err != nil {
		return nil, fmt.Errorf("解析 data 失败: %v", err)
	}

	// 将解析后的数据重新编码为 []byte
	resultBytes, err := json.Marshal(parsedData)
	if err != nil {
		return nil, fmt.Errorf("重新编码 data 失败: %v", err)
	}

	return resultBytes, nil
}

// G37SC01 自然人失信信息
func (a *ApiRequestService) ProcessG37SC01Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, G37SC01, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name":   a.westDexService.Encrypt(name.String()),
			"idcard": a.westDexService.Encrypt(idCard.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G37SC01", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 第一步：提取外层的 data 字段
	dataResult := gjson.GetBytes(resp, "data")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("外层 data 字段不存在")
	}

	// 解析 data 字符串为 JSON 对象
	parsedData := gjson.Parse(dataResult.String())
	sxbzxr := parsedData.Get("sxbzxr")
	if !sxbzxr.Exists() {
		return nil, fmt.Errorf("内层 sxbzxr 字段不存在")
	}
	return []byte(sxbzxr.Raw), nil
}

// G36SC01 自然人限高信息
func (a *ApiRequestService) ProcessG36SC01Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, G36SC01, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name":   a.westDexService.Encrypt(name.String()),
			"idcard": a.westDexService.Encrypt(idCard.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G36SC01", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 第一步：提取外层的 data 字段
	dataResult := gjson.GetBytes(resp, "data")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("外层 data 字段不存在")
	}

	// 解析 data 字符串为 JSON 对象
	parsedData := gjson.Parse(dataResult.String())
	xgbzxr := parsedData.Get("xgbzxr")
	if !xgbzxr.Exists() {
		return nil, fmt.Errorf("内层 xgbzxr 字段不存在")
	}
	return []byte(xgbzxr.Raw), nil
}

// G22SC01 自然人司法模型
func (a *ApiRequestService) ProcessG22SC01Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, G22SC01, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name":          a.westDexService.Encrypt(name.String()),
			"idcard":        a.westDexService.Encrypt(idCard.String()),
			"inquired_auth": a.westDexService.GetDateRange(),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G22SC01", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 第一步：提取外层的 data 字段
	dataResult := gjson.GetBytes(resp, "data")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("外层 data 字段不存在")
	}

	parseResult, err := lzUtils.RecursiveParse(dataResult.Raw)
	if err != nil {
		return nil, fmt.Errorf("递归反序列化")
	}
	marshal, err := sonic.Marshal(parseResult)
	if err != nil {
		return nil, fmt.Errorf("序列化失败: %v", err)
	}
	return marshal, nil
}

// Q03SC01 企业涉诉信息
func (a *ApiRequestService) ProcessQ03SC01Request(params []byte) ([]byte, error) {
	entName := gjson.GetBytes(params, "ent_name")
	entCode := gjson.GetBytes(params, "ent_code")

	if !entName.Exists() || !entCode.Exists() {
		return nil, errors.New("api请求, Q03SC01, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"uscc":          a.westDexService.Encrypt(entCode.String()),
			"org_name":      a.westDexService.Encrypt(entName.String()),
			"inquired_auth": a.westDexService.GetDateRange(),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("Q03SC01", request)
	if callApiErr != nil {
		return nil, callApiErr
	}

	// 第一步：提取外层的 data 字段
	dataResult := gjson.GetBytes(resp, "data")
	if !dataResult.Exists() {
		return nil, fmt.Errorf("外层 data 字段不存在")
	}

	// 保留原有的递归解析和序列化逻辑
	parseResult, err := lzUtils.RecursiveParse(dataResult.Raw)
	if err != nil {
		return nil, fmt.Errorf("递归反序列化")
	}
	logx.Infof("parseResult: %v", parseResult)
	marshal, err := sonic.Marshal(parseResult)
	if err != nil {
		return nil, fmt.Errorf("序列化失败: %v", err)
	}
	// 第二步：使用gjson预处理数据
	dataMap := make(map[string]interface{})

	// 处理entout数据
	entoutArray := gjson.GetBytes(marshal, "entout").Array()
	if len(entoutArray) > 0 {
		// 检查是否存在count字段来判断是否有数据
		countField := entoutArray[0].Get("data.count")
		if countField.Exists() {
			// 有count字段，表示有数据
			entoutData := entoutArray[0].Get("data")
			if entoutData.Exists() {
				dataMap["data"] = json.RawMessage(entoutData.Raw)
			}
		} else {
			// 没有count字段，使用空对象
			dataMap["data"] = json.RawMessage("{}")
		}
	} else {
		dataMap["data"] = json.RawMessage("{}")
	}

	// 处理sxbzxr数据(失信被执行人)
	sxbzxrArray := dataResult.Get("sxbzxr").Array()
	if len(sxbzxrArray) > 0 {
		sxbzxrList := sxbzxrArray[0].Get("sxbzxr")
		if sxbzxrList.Exists() && len(sxbzxrList.Array()) > 0 {
			dataMap["sxbzxr"] = json.RawMessage(sxbzxrList.Raw)
		} else {
			dataMap["sxbzxr"] = json.RawMessage("[]")
		}
	} else {
		dataMap["sxbzxr"] = json.RawMessage("[]")
	}

	// 处理xgbzxr数据(限高被执行人)
	xgbzxrArray := dataResult.Get("xgbzxr").Array()
	if len(xgbzxrArray) > 0 {
		xgbzxrList := xgbzxrArray[0].Get("xgbzxr")
		if xgbzxrList.Exists() && len(xgbzxrList.Array()) > 0 {
			dataMap["xgbzxr"] = json.RawMessage(xgbzxrList.Raw)
		} else {
			dataMap["xgbzxr"] = json.RawMessage("[]")
		}
	} else {
		dataMap["xgbzxr"] = json.RawMessage("[]")
	}

	result, err := sonic.Marshal(dataMap)
	if err != nil {
		return nil, fmt.Errorf("序列化预处理数据失败: %v", err)
	}

	return result, nil
}

// G39SC02 职业资格证书核验
func (a *ApiRequestService) ProcessG39SC02Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, G39SC02, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name":  a.westDexService.Encrypt(name.String()),
			"IdNum": a.westDexService.Encrypt(idCard.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G39SC02", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	return resp, nil
}

// G38SC02 全国个人离婚次数
func (a *ApiRequestService) ProcessG38SC02Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, G38SC02, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"xm":   a.westDexService.Encrypt(name.String()),
			"sfzh": a.westDexService.Encrypt(idCard.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G38SC02", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	return resp, nil

}

// layoutIdcard 西部二要素
func (a *ApiRequestService) ProcessLayoutIdcardRequest(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")

	if !name.Exists() || !idCard.Exists() {
		return nil, errors.New("api请求, layoutIdcard, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"xM":             a.westDexService.Encrypt(name.String()),
			"gMSFZHM":        a.westDexService.Encrypt(idCard.String()),
			"customerNumber": a.config.WestConfig.SecretId,
			"timeStamp":      fmt.Sprintf("%d", time.Now().UnixNano()/int64(time.Millisecond)),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("layoutIdcard", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	// 使用gjson获取resultCode
	resultCode := gjson.GetBytes(resp, "ctidRequest.ctidAuth.resultCode")
	if !resultCode.Exists() {
		return nil, errors.New("获取resultCode失败")
	}

	// 获取resultCode的第一个字符
	resultCodeStr := resultCode.String()
	if len(resultCodeStr) == 0 {
		return nil, errors.New("resultCode为空")
	}

	firstChar := string(resultCodeStr[0])
	if firstChar != "0" && firstChar != "5" {
		return nil, errors.New("resultCode的第一个字符既不是0也不是5")
	}
	return []byte(firstChar), nil
}

// PersonEnterprisePro 人企业关系加强版
func (a *ApiRequestService) ProcessPersonEnterpriseProRequest(params []byte) ([]byte, error) {
	idCard := gjson.GetBytes(params, "id_card")
	// 设置最大调用次数上限
	maxApiCalls := 20 // 允许最多查询20个企业

	if !idCard.Exists() {
		return nil, errors.New("api请求, PersonEnterprisePro, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"pid": crypto.Md5Encrypt(idCard.String()),
	}
	resp, callApiErr := a.westDexService.G05HZ01CallAPI("G05HZ01", request)
	if callApiErr != nil {
		return nil, callApiErr
	}

	// 处理股东人企关系的响应数据
	code := gjson.GetBytes(resp, "code")
	if !code.Exists() {
		return nil, fmt.Errorf("响应中缺少 code 字段")
	}

	// 判断 code 是否等于 "0000"
	if code.String() == "0000" {
		// 获取 data 字段的值
		data := gjson.GetBytes(resp, "data")
		if !data.Exists() {
			return nil, fmt.Errorf("响应中缺少 data 字段")
		}

		// 使用gjson获取企业列表
		datalistResult := gjson.Get(data.Raw, "datalist")
		if !datalistResult.Exists() {
			return nil, fmt.Errorf("datalist字段不存在")
		}

		// 获取所有企业并进行排序
		companies := datalistResult.Array()

		// 创建企业对象切片，用于排序
		type CompanyWithPriority struct {
			Index           int
			Data            gjson.Result
			RelationshipVal int // 关系权重值
			RelationCount   int // 关系数量
			AdminPenalty    int // 行政处罚数量
			Executed        int // 被执行人数量
			Dishonest       int // 失信被执行人数量
		}

		companiesWithPriority := make([]CompanyWithPriority, 0, len(companies))

		// 遍历企业，计算优先级
		for i, companyJson := range companies {
			// 统计行政处罚、被执行人、失信被执行人
			adminPenalty := 0
			executed := 0
			dishonest := 0

			// 检查行政处罚字段是否存在并获取数组长度
			adminPenaltyResult := companyJson.Get("adminPenalty")
			if adminPenaltyResult.Exists() && adminPenaltyResult.IsArray() {
				adminPenalty = len(adminPenaltyResult.Array())
			}

			// 检查被执行人字段是否存在并获取数组长度
			executedPersonResult := companyJson.Get("executedPerson")
			if executedPersonResult.Exists() && executedPersonResult.IsArray() {
				executed = len(executedPersonResult.Array())
			}

			// 检查失信被执行人字段是否存在并获取数组长度
			dishonestExecutedPersonResult := companyJson.Get("dishonestExecutedPerson")
			if dishonestExecutedPersonResult.Exists() && dishonestExecutedPersonResult.IsArray() {
				dishonest = len(dishonestExecutedPersonResult.Array())
			}

			// 计算relationship权重
			relationshipVal := 0
			relationCount := 0

			// 获取relationship数组
			relationshipResult := companyJson.Get("relationship")
			if relationshipResult.Exists() && relationshipResult.IsArray() {
				relationships := relationshipResult.Array()
				// 统计各类关系的数量和权重
				for _, rel := range relationships {
					relationCount++
					relStr := rel.String()

					// 根据关系类型设置权重，权重顺序：
					// 股东(6) > 历史股东(5) > 法人(4) > 历史法人(3) > 高管(2) > 历史高管(1)
					switch relStr {
					case "sh": // 股东
						if relationshipVal < 6 {
							relationshipVal = 6
						}
					case "his_sh": // 历史股东
						if relationshipVal < 5 {
							relationshipVal = 5
						}
					case "lp": // 法人
						if relationshipVal < 4 {
							relationshipVal = 4
						}
					case "his_lp": // 历史法人
						if relationshipVal < 3 {
							relationshipVal = 3
						}
					case "tm": // 高管
						if relationshipVal < 2 {
							relationshipVal = 2
						}
					case "his_tm": // 历史高管
						if relationshipVal < 1 {
							relationshipVal = 1
						}
					}
				}
			}

			companiesWithPriority = append(companiesWithPriority, CompanyWithPriority{
				Index:           i,
				Data:            companyJson,
				RelationshipVal: relationshipVal,
				RelationCount:   relationCount,
				AdminPenalty:    adminPenalty,
				Executed:        executed,
				Dishonest:       dishonest,
			})
		}

		// 按优先级排序
		sort.Slice(companiesWithPriority, func(i, j int) bool {
			// 首先根据是否有失信被执行人排序
			if companiesWithPriority[i].Dishonest != companiesWithPriority[j].Dishonest {
				return companiesWithPriority[i].Dishonest > companiesWithPriority[j].Dishonest
			}

			// 然后根据是否有被执行人排序
			if companiesWithPriority[i].Executed != companiesWithPriority[j].Executed {
				return companiesWithPriority[i].Executed > companiesWithPriority[j].Executed
			}

			// 然后根据是否有行政处罚排序
			if companiesWithPriority[i].AdminPenalty != companiesWithPriority[j].AdminPenalty {
				return companiesWithPriority[i].AdminPenalty > companiesWithPriority[j].AdminPenalty
			}

			// 然后按relationship类型排序
			if companiesWithPriority[i].RelationshipVal != companiesWithPriority[j].RelationshipVal {
				return companiesWithPriority[i].RelationshipVal > companiesWithPriority[j].RelationshipVal
			}

			// 最后按relationship数量排序
			return companiesWithPriority[i].RelationCount > companiesWithPriority[j].RelationCount
		})

		// 限制处理的企业数量
		processCount := len(companiesWithPriority)
		if processCount > maxApiCalls {
			processCount = maxApiCalls
		}

		// 只处理前N个优先级高的企业
		prioritizedCompanies := companiesWithPriority[:processCount]

		// 使用WaitGroup和chan处理并发
		var wg sync.WaitGroup
		results := make(chan struct {
			index int
			data  []byte
			err   error
		}, processCount)

		// 对按优先级排序的前N个企业进行涉诉信息查询
		for _, company := range prioritizedCompanies {
			wg.Add(1)
			go func(origIndex int, companyInfo gjson.Result) {
				defer wg.Done()
				logx.Infof("开始处理企业[%d]，企业名称: %s，统一社会信用代码: %s", origIndex, companyInfo.Get("basicInfo.name").String(), companyInfo.Get("basicInfo.creditCode").String())
				// 提取企业名称和统一社会信用代码
				orgName := companyInfo.Get("basicInfo.name")
				creditCode := companyInfo.Get("basicInfo.creditCode")

				if !orgName.Exists() || !creditCode.Exists() {
					results <- struct {
						index int
						data  []byte
						err   error
					}{origIndex, nil, fmt.Errorf("企业名称或统一社会信用代码不存在")}
					return
				}

				// 解析原始公司信息为map
				var companyMap map[string]interface{}
				if err := json.Unmarshal([]byte(companyInfo.Raw), &companyMap); err != nil {
					results <- struct {
						index int
						data  []byte
						err   error
					}{origIndex, nil, fmt.Errorf("解析企业信息失败: %v", err)}
					return
				}

				// 构造调用Q03SC01的参数
				q03Params, err := json.Marshal(map[string]string{
					"ent_name": orgName.String(),
					"ent_code": creditCode.String(),
				})
				if err != nil {
					// 参数构造失败，但不影响整体处理
					logx.Errorf("构造企业[%s]涉诉查询参数失败: %v", orgName.String(), err)
					companyMap["lawsuitInfo"] = map[string]interface{}{}
				} else {
					// 调用Q03SC01接口获取企业涉诉信息
					lawsuitData, err := a.ProcessQ03SC01Request(q03Params)
					// 无论是否有错误，都继续处理
					if err != nil {
						// 可能是正常没有涉诉数据，设置为空对象
						logx.Infof("企业[%s]涉诉信息查询结果: %v", orgName.String(), err)
						companyMap["lawsuitInfo"] = map[string]interface{}{}
					} else if len(lawsuitData) == 0 || string(lawsuitData) == "{}" || string(lawsuitData) == "null" {
						// 无涉诉数据
						companyMap["lawsuitInfo"] = map[string]interface{}{}
					} else {
						// 解析涉诉信息
						var lawsuitInfo interface{}
						if err := json.Unmarshal(lawsuitData, &lawsuitInfo); err != nil {
							logx.Errorf("解析企业[%s]涉诉信息失败: %v", orgName.String(), err)
							companyMap["lawsuitInfo"] = map[string]interface{}{}
						} else {
							// 添加涉诉信息到企业信息中
							companyMap["lawsuitInfo"] = lawsuitInfo
						}
					}
				}

				// 序列化更新后的企业信息
				companyData, err := json.Marshal(companyMap)
				if err != nil {
					results <- struct {
						index int
						data  []byte
						err   error
					}{origIndex, nil, fmt.Errorf("序列化企业信息失败: %v", err)}
					return
				}

				results <- struct {
					index int
					data  []byte
					err   error
				}{origIndex, companyData, nil}
			}(company.Index, company.Data)
		}

		// 关闭结果通道
		go func() {
			wg.Wait()
			close(results)
		}()

		// 解析原始数据为map
		var dataMap map[string]interface{}
		if err := json.Unmarshal([]byte(data.Raw), &dataMap); err != nil {
			return nil, fmt.Errorf("解析data字段失败: %v", err)
		}

		// 获取原始企业列表
		originalDatalist, ok := dataMap["datalist"].([]interface{})
		if !ok {
			return nil, fmt.Errorf("无法获取原始企业列表")
		}

		// 创建结果映射，用于保存已处理的企业
		processedCompanies := make(map[int]interface{})

		// 收集处理过的企业数据
		for result := range results {
			if result.err != nil {
				logx.Errorf("处理企业失败: %v", result.err)
				continue
			}

			if result.data != nil {
				var companyMap interface{}
				if err := json.Unmarshal(result.data, &companyMap); err == nil {
					processedCompanies[result.index] = companyMap
				}
			}
		}

		// 更新企业列表
		// 处理过的用新数据，未处理的保留原样
		updatedDatalist := make([]interface{}, len(originalDatalist))
		for i, company := range originalDatalist {
			if processed, exists := processedCompanies[i]; exists {
				// 已处理的企业，使用新数据
				updatedDatalist[i] = processed
			} else {
				// 未处理的企业，保留原始数据并添加空的涉诉信息
				companyMap, ok := company.(map[string]interface{})
				if ok {
					// 为未处理的企业添加空的涉诉信息
					companyMap["lawsuitInfo"] = map[string]interface{}{}
					updatedDatalist[i] = companyMap
				} else {
					updatedDatalist[i] = company
				}
			}
		}

		// 更新原始数据中的企业列表
		dataMap["datalist"] = updatedDatalist

		// 序列化最终结果
		result, err := json.Marshal(dataMap)
		if err != nil {
			return nil, fmt.Errorf("序列化最终结果失败: %v", err)
		}

		return result, nil
	}

	// code不等于"0000"，返回错误
	return nil, fmt.Errorf("响应code错误: %s", code.String())
}

func (a *ApiRequestService) ProcessBehaviorRiskScanRequest(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	mobile := gjson.GetBytes(params, "mobile")

	if !name.Exists() || !idCard.Exists() || !mobile.Exists() {
		return nil, errors.New("api请求, BehaviorRiskScan, 获取相关参数失败")
	}

	var wg sync.WaitGroup
	type apiResult struct {
		name string
		data []byte
		err  error
	}
	results := make(chan apiResult, 5) // 5个风险检测项

	// 并行调用五个不同的风险检测API
	wg.Add(4)

	// 黑灰产检测
	go func() {
		defer wg.Done()
		data, err := a.ProcessG30BJ05Request(params)
		results <- apiResult{name: "black_gray_level", data: data, err: err}
	}()

	// 电诈风险预警
	go func() {
		defer wg.Done()
		data, err := a.ProcessG31BJ05Request(params)
		results <- apiResult{name: "telefraud_level", data: data, err: err}
	}()

	// 团伙欺诈排查
	go func() {
		defer wg.Done()
		data, err := a.ProcessG32BJ05Request(params)
		results <- apiResult{name: "fraud_group", data: data, err: err}
	}()

	// // 反诈反赌核验
	go func() {
		defer wg.Done()
		data, err := a.ProcessRIS031Request(params)
		results <- apiResult{name: "anti_fraud_gaming", data: data, err: err}
	}()

	// 风险等级
	go func() {
		defer wg.Done()
		data, err := a.ProcessG34BJ03Request(params)
		results <- apiResult{name: "risk_level", data: data, err: err}
	}()

	// 关闭结果通道
	go func() {
		wg.Wait()
		close(results)
	}()

	// 收集所有结果
	resultMap := make(map[string]interface{})
	var errors []string

	for result := range results {
		if result.err != nil {
			// 记录错误但继续处理其他结果
			errors = append(errors, fmt.Sprintf("%s: %v", result.name, result.err))
			continue
		}

		// 解析JSON结果并添加到结果映射
		var parsedData interface{}
		if err := json.Unmarshal(result.data, &parsedData); err != nil {
			errors = append(errors, fmt.Sprintf("解析%s数据失败: %v", result.name, err))
		} else {
			resultMap[result.name] = parsedData
		}
	}

	// 添加错误信息到结果中(如果存在)
	if len(errors) > 0 {
		resultMap["errors"] = errors
	}

	// 序列化最终结果
	finalResult, err := json.Marshal(resultMap)
	if err != nil {
		return nil, fmt.Errorf("序列化行为风险扫描结果失败: %v", err)
	}

	return finalResult, nil
}

// G30BJ05 黑灰产
func (a *ApiRequestService) ProcessG30BJ05Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	Mobile := gjson.GetBytes(params, "mobile")

	if !name.Exists() || !idCard.Exists() || !Mobile.Exists() {
		return nil, errors.New("api请求, G30BJ05, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name": a.westDexService.Encrypt(name.String()),
			"id":   a.westDexService.Encrypt(idCard.String()),
			"cell": a.westDexService.Encrypt(Mobile.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G30BJ05", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	fmt.Println(resp)
	flagBlackgraylevel := gjson.GetBytes(resp, "flag_blackgraylevel")
	if !flagBlackgraylevel.Exists() || flagBlackgraylevel.String() != "1" {
		return nil, fmt.Errorf("自然人黑灰产信息查询失败")
	}

	bglLevel := gjson.GetBytes(resp, "bgl_level")
	if !bglLevel.Exists() {
		return nil, fmt.Errorf("bgl_level 字段不存在")
	}

	return []byte(bglLevel.Raw), nil
}

// G31BJ05 电诈风险预警
func (a *ApiRequestService) ProcessG31BJ05Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	Mobile := gjson.GetBytes(params, "mobile")

	if !name.Exists() || !idCard.Exists() || !Mobile.Exists() {
		return nil, errors.New("api请求, G31BJ05, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name": a.westDexService.Encrypt(name.String()),
			"id":   a.westDexService.Encrypt(idCard.String()),
			"cell": a.westDexService.Encrypt(Mobile.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G31BJ05", request)
	if callApiErr != nil {
		return nil, callApiErr
	}
	fmt.Println(resp)
	flagTelefraudpredictstd := gjson.GetBytes(resp, "flag_telefraudpredictstd")
	if !flagTelefraudpredictstd.Exists() || flagTelefraudpredictstd.String() != "1" {
		return nil, fmt.Errorf("自然人电诈风险预警查询失败")
	}

	tfpsLevel := gjson.GetBytes(resp, "tfps_level")
	if !tfpsLevel.Exists() {
		return nil, fmt.Errorf("tfps_level 字段不存在")
	}

	return []byte(tfpsLevel.Raw), nil
}

// G32BJ05 团伙欺诈排查
func (a *ApiRequestService) ProcessG32BJ05Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	Mobile := gjson.GetBytes(params, "mobile")

	if !name.Exists() || !idCard.Exists() || !Mobile.Exists() {
		return nil, errors.New("api请求, G32BJ05, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name": a.westDexService.Encrypt(name.String()),
			"id":   a.westDexService.Encrypt(idCard.String()),
			"cell": a.westDexService.Encrypt(Mobile.String()),
		},
	}
	resp, callApiErr := a.westDexService.CallAPI("G32BJ05", request)
	if callApiErr != nil {
		return nil, callApiErr
	}

	flagFraudrelation := gjson.GetBytes(resp, "flag_fraudrelation")
	if !flagFraudrelation.Exists() || flagFraudrelation.String() != "1" {
		return nil, fmt.Errorf("自然人团伙欺诈排查查询失败")
	}
	frgListLevel := gjson.GetBytes(resp, "frg_list_level")
	if !frgListLevel.Exists() {
		return nil, fmt.Errorf("frg_list_level 字段不存在")
	}

	frgGroupNum := gjson.GetBytes(resp, "frg_group_num")
	if !frgGroupNum.Exists() {
		return nil, fmt.Errorf("frg_group_num 字段不存在")
	}

	// 构建包含两个字段的JSON响应
	result := map[string]interface{}{
		"frg_list_level": frgListLevel.Value(),
		"frg_group_num":  frgGroupNum.Value(),
	}

	resultJSON, err := json.Marshal(result)
	if err != nil {
		return nil, fmt.Errorf("序列化结果失败: %v", err)
	}

	return resultJSON, nil
}

// RIS031 反诈反赌核验
func (a *ApiRequestService) ProcessRIS031Request(params []byte) ([]byte, error) {
	name := gjson.GetBytes(params, "name")
	idCard := gjson.GetBytes(params, "id_card")
	Mobile := gjson.GetBytes(params, "mobile")

	if !name.Exists() || !idCard.Exists() || !Mobile.Exists() {
		return nil, errors.New("api请求, RIS031, 获取相关参数失败")
	}

	request := map[string]interface{}{
		"data": map[string]interface{}{
			"name": a.westDexService.Encrypt(name.String()),
			"id":   a.westDexService.Encrypt(idCard.String()),
			"cell": a.westDexService.Encrypt(Mobile.String()),
		},
	}
	resp, callApiErr := a.yushanService.request("RIS031", request)
	if callApiErr != nil {
		return nil, callApiErr
	}

	Value := gjson.GetBytes(resp, "value")
	if !Value.Exists() {
		return nil, fmt.Errorf("自然人反诈反赌核验查询失败")
	}

	return []byte(Value.Raw), nil
}
func (a *ApiRequestService) ProcessG09XM02Request(params []byte) ([]byte, error) {
	idCard := gjson.GetBytes(params, "id_card")
	name := gjson.GetBytes(params, "name")
	if !idCard.Exists() || !name.Exists() {
		return nil, errors.New("api请求, G09XM02, 获取相关参数失败")
	}
	request := map[string]interface{}{
		"data": map[string]interface{}{
			"idCard": a.westDexService.Encrypt(idCard.String()),
			"name":   a.westDexService.Encrypt(name.String()),
		},
	}
	resp, err := a.westDexService.CallAPI("G09XM02", request)
	if err != nil {
		return nil, fmt.Errorf("婚姻状态查询失败: %v", err)
	}
	// gjson.GetBytes(resp, "maritalStatus")
	return resp, nil
}

func (a *ApiRequestService) ProcessG10XM02Request(params []byte) ([]byte, error) {
	// 提取男方和女方信息
	nameMan := gjson.GetBytes(params, "nameMan")
	idCardMan := gjson.GetBytes(params, "idCardMan")
	nameWoman := gjson.GetBytes(params, "nameWoman")
	idCardWoman := gjson.GetBytes(params, "idCardWoman")

	// 校验是否存在必要参数
	if !nameMan.Exists() || !idCardMan.Exists() || !nameWoman.Exists() || !idCardWoman.Exists() {
		return nil, errors.New("请求参数缺失：需要提供男方和女方的姓名及身份证号")
	}

	// 构造请求数据
	request := map[string]interface{}{
		"data": map[string]interface{}{
			"idCardMan":   a.westDexService.Encrypt(idCardMan.String()),
			"nameMan":     a.westDexService.Encrypt(nameMan.String()),
			"idCardWoman": a.westDexService.Encrypt(idCardWoman.String()),
			"nameWoman":   a.westDexService.Encrypt(nameWoman.String()),
		},
	}

	// 调用 API
	resp, callApiErr := a.westDexService.CallAPI("G10XM02", request)
	if callApiErr != nil {
		return nil, callApiErr
	}

	return resp, nil
}
func (a *ApiRequestService) ProcessG11BJ06Request(params []byte) ([]byte, error) {
	idCard := gjson.GetBytes(params, "id_card")
	name := gjson.GetBytes(params, "name")
	if !idCard.Exists() || !name.Exists() {
		return nil, errors.New("api请求, G11BJ06, 获取相关参数失败")
	}
	request := map[string]interface{}{
		"data": map[string]interface{}{
			"id_card_value": a.westDexService.Encrypt(idCard.String()),
			"name_value":    a.westDexService.Encrypt(name.String()),
		},
	}
	resp, err := a.westDexService.CallAPI("G11BJ06", request)
	if err != nil {
		return nil, fmt.Errorf("教育经历核验查询失败: %v", err)
	}
	return resp, nil
}