package service

import (
	"bytes"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"qnc-server/config"
	"qnc-server/model/model"
	"qnc-server/model/response"
	"qnc-server/utils"
	"strconv"
	"strings"
	"time"
)

type RequestService struct {
}

func (r *RequestService) AliYunRequest(method string, urlStr string, params map[string]string, body map[string]any) (data string, err error) {
	appCode := config.ConfigData.LawsuitQuery.AppCode
	// 创建查询参数
	// 构造 URL 参数
	if method == http.MethodGet && len(params) > 0 {
		queryParams := url.Values{}
		for key, value := range params {
			queryParams.Add(key, value)
		}
		urlStr = fmt.Sprintf("%s?%s", urlStr, queryParams.Encode())
	}

	req, err := http.NewRequest(string(method), urlStr, nil)
	if err != nil {
		log.Printf("【阿里云市场请求】创建请求失败 err:%v", err)
		return "", err
	}

	// 设置请求头
	req.Header.Set("Authorization", "APPCODE "+appCode)

	if method == http.MethodPost && body != nil {
		formData := url.Values{}
		for key, value := range body {
			formData.Set(key, fmt.Sprintf("%v", value))
		}
		req.Body = io.NopCloser(strings.NewReader(formData.Encode()))
		req.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
	}

	// 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("【阿里云市场请求】请求失败，\nURL：%s \nerr：%v", req.URL, err)
		return
	}
	defer resp.Body.Close()
	// 检查响应状态码
	if resp.StatusCode != http.StatusOK {
		log.Printf("请求失败，状态码: %d", resp.StatusCode)
		return "", fmt.Errorf("【阿里云市场请求】请求失败，\nURL：%s \n状态码: %d", req.URL, resp.StatusCode)
	}

	// 读取响应体
	respBody, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("【阿里云市场请求】响应体读取失败，\nURL：%s \n响应：%s \nerr：%v", req.URL, resp.Body, err)
		return
	}
	return string(respBody), nil
}

// 羽山请求
func (r *RequestService) YuShanRequest(prodID string, reqData map[string]interface{}) (plainText []byte, err error) {
	currentTime := time.Now()
	unixMilliseconds := currentTime.UnixNano() / int64(time.Millisecond)
	requestSN, _ := utils.GenerateRandomString()
	apiKey := config.ConfigData.Antifraud.ApiKey
	acctId := config.ConfigData.Antifraud.AcctId
	httpUrl := config.ConfigData.Antifraud.HttpUrl
	// 根据 ProdID 动态构建请求数据
	reqBody := map[string]interface{}{
		"prod_id":    prodID,
		"req_time":   unixMilliseconds,
		"request_sn": requestSN,
		"req_data":   reqData,
	}

	messageBytes, err := json.Marshal(reqBody)
	if err != nil {
		return
	}
	key, err := hex.DecodeString(apiKey)
	if err != nil {
		return
	}
	//加密
	cipherText := utils.AES_CBC_Encrypt(messageBytes, key)

	content := base64.StdEncoding.EncodeToString(cipherText)
	respStr, err := httpDo(httpUrl, content, acctId)
	if err != nil {
		return
	}
	//解密
	sDec, err := base64.StdEncoding.DecodeString(respStr)
	if err != nil {
		if utils.IsJSON(respStr) {
			return []byte(respStr), nil
		}
		return
	}
	plainText = utils.AES_CBC_Decrypt(sDec, key)
	return
}

// 解析羽山响应数据
func (r *RequestService) AnalysisDataYuShan(respByte []byte) (data []map[string]interface{}, err error) {
	var resp model.YuShanResponse[[]map[string]interface{}]
	err = json.Unmarshal(respByte, &resp)
	if err != nil {
		return nil, utils.ErrSystemError
	}
	if resp.Retcode == RetCodeSuccess {
		data = resp.Retdata
		return data, nil
	} else if resp.Retcode == RetCodeEmpty {
		return data, utils.ErrNoRecord
	} else {
		return data, errors.New(resp.Retmsg)
	}
}

// 三要素解析
func (r *RequestService) ThreeElementsParse(threeElementsResp string) (resp response.ThreeElementsResp, err error) {
	err = json.Unmarshal([]byte(threeElementsResp), &resp)
	if err != nil {
		log.Printf("【三要素响应解析】解析错误 err:%v", err)
		return
	}
	return resp, nil
}

// westdex 西部数据API请求
func (r *RequestService) WestDexRequest(code string, reqData map[string]interface{}) (respStr string, err error) {
	// 生成当前的13位时间戳
	timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)

	// 构造请求URL
	secretId := "449159"
	reqUrl := fmt.Sprintf("https://apimaster.westdex.com.cn/api/invoke/%s/%s?timestamp=%s", secretId, code, timestamp)

	// 将请求参数编码为JSON格式
	data := map[string]interface{}{
		"data": reqData,
	}
	jsonData, err := json.Marshal(data)
	if err != nil {
		log.Printf("【西部数据请求】JSON编码错误: %v", err)
		return
	}

	// 创建HTTP POST请求
	req, err := http.NewRequest("POST", reqUrl, bytes.NewBuffer(jsonData))
	if err != nil {
		log.Printf("【西部数据请求】创建请求错误: %v", err)
		return
	}

	// 设置请求头
	req.Header.Set("Content-Type", "application/json")

	// 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("【西部数据请求】发送请求错误: %v", err)
		return
	}
	defer resp.Body.Close()

	// 检查请求是否成功
	if resp.StatusCode == 200 {
		// 读取响应体
		bodyBytes, err := io.ReadAll(resp.Body)
		if err != nil {
			log.Printf("【西部数据请求】读取响应体错误: %v", err)
			return "", err
		}

		// 手动调用 json.Unmarshal 触发自定义的 UnmarshalJSON 方法
		var westDexResp response.WestdexResp
		err = json.Unmarshal(bodyBytes, &westDexResp)
		if err != nil {
			log.Printf("【西部数据请求】JSON反序列化错误: %v", err)
			return "", err
		}
		key := "121a1e41fc1690dd6b90afbcacd80cf4" // 你的AES密钥

		if westDexResp.Code != "00000" {
			//decryptedData, err := utils.WestDexDecrypt(westDexResp.Data, key)
			if err != nil {
				log.Printf("【西部数据请求】响应数据解密错误: %v", err)
				return "", err
			}
			log.Printf("【西部数据请求】响应数据业务失败：%v", westDexResp.Message)
			return "", errors.New("业务失败")
		}
		// 解密响应数据
		decryptedData, err := utils.WestDexDecrypt(westDexResp.Data, key)
		if err != nil {
			log.Printf("【西部数据请求】响应数据解密错误: %v", err)
			return "", err
		}
		// 输出解密后的数据
		log.Printf("【西部数据请求】解密后的响应数据: %s", decryptedData)
		return decryptedData, nil
	}
	log.Printf("【西部数据请求】请求失败，状态码: %s", resp.Status)
	return
}