package service

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"qnc-server/config"
	"qnc-server/db"
	"qnc-server/model/model"
	"qnc-server/model/request"
	"qnc-server/model/response"
	"qnc-server/utils"
)

type LawsuitQueryService struct {
}

func (l *LawsuitQueryService) QueryList(reqData request.LawsuitQueryReq) (data []response.CaseDetail, err error) {
	baseURL := config.ConfigData.LawsuitQuery.ListURL
	appCode := config.ConfigData.LawsuitQuery.AppCode
	// 创建查询参数
	params := url.Values{}
	params.Add("sign", utils.GenerateMD5())
	params.Add("entityName", reqData.Name)
	params.Add("entityId", reqData.CardNo)
	params.Add("needBranch", "1")
	params.Add("fl", "1")

	// 构建完整的请求 URL
	requestURL := fmt.Sprintf("%s?%s", baseURL, params.Encode())

	// 创建请求
	reqBody := bytes.NewBuffer([]byte{})
	req, err := http.NewRequest("POST", requestURL, reqBody)
	if err != nil {
		log.Printf("failed 创建请求: %v", err)
		return
	}
	// 设置请求头
	req.Header.Set("Authorization", "APPCODE "+appCode)
	// 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("failed 发送请求: %v", err)
		return
	}
	defer resp.Body.Close()

	// 读取响应体
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("failed 读取响应体: %v", err)
		return
	}
	var queryResp response.LawsuitQueryListResponse
	err = json.Unmarshal(body, &queryResp)
	if err != nil {
		log.Printf("query list failed to unmarshal response: %v", err)
		return
	}
	switch queryResp.Rc {
	case "0000":
		var respData response.LawsuitQueryListData
		queryRespBytes, err := json.Marshal(queryResp.Data)
		if err != nil {
			log.Printf("queryResp Marshal Error: %v", err)
			return nil, fmt.Errorf("响应错误，请稍后再试")
		}
		err = json.Unmarshal(queryRespBytes, &respData)
		if err != nil {
			log.Printf("sxr queryResp Unmarshal Error: %v", err)
			return nil, fmt.Errorf("响应错误，请稍后再试")
		}
		return respData.List, nil
	case "0001":
		log.Printf("涉诉专业版查询成功无数据: %v", queryResp.Msg)
		return data, nil
	case "1000":
		log.Printf("apikey校验失败: %v", err)
		return data, fmt.Errorf("响应错误，请稍后再试")
	default:
		log.Printf("未知响应代码: %s", queryResp.Rc)
		return data, fmt.Errorf("响应错误，请稍后再试")
	}
}

func (l *LawsuitQueryService) QuerySxrList(reqData request.LawsuitQueryReq) (data []response.SxrDetail, err error) {
	baseURL := config.ConfigData.LawsuitQuery.SxrURL
	appCode := config.ConfigData.LawsuitQuery.AppCode
	// 创建查询参数
	params := url.Values{}
	params.Add("sign", utils.GenerateMD5())
	params.Add("entityName", reqData.Name)
	params.Add("entityId", reqData.CardNo)
	params.Add("btype", "1")
	params.Add("related", "0")

	// 构建完整的请求 URL
	requestURL := fmt.Sprintf("%s?%s", baseURL, params.Encode())

	// 创建请求
	reqBody := bytes.NewBuffer([]byte{})
	req, err := http.NewRequest("POST", requestURL, reqBody)
	if err != nil {
		log.Printf("failed 创建请求: %v", err)
		return
	}
	// 设置请求头
	req.Header.Set("Authorization", "APPCODE "+appCode)
	// 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("failed 发送请求: %v", err)
		return
	}
	defer resp.Body.Close()

	// 读取响应体
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("failed 读取响应体: %v", err)
		return
	}
	var queryResp response.LawsuitQueryListResponse
	err = json.Unmarshal(body, &queryResp)
	if err != nil {
		log.Printf("sxr failed to unmarshal response: %v", err)
		return
	}
	switch queryResp.Rc {
	case "0000":
		var respData []response.SxrDetail
		queryRespBytes, err := json.Marshal(queryResp.Data)
		if err != nil {
			log.Printf("queryResp Marshal Error: %v", err)
			return nil, fmt.Errorf("响应错误，请稍后再试")
		}
		err = json.Unmarshal(queryRespBytes, &respData)
		if err != nil {
			log.Printf("sxr queryResp Unmarshal Error: %v", err)
			return nil, fmt.Errorf("响应错误，请稍后再试")
		}
		return respData, nil
	case "0001":
		return data, nil
	case "1000":
		log.Printf("apikey校验失败: %v", err)
		return data, fmt.Errorf("响应错误，请稍后再试")
	default:
		log.Printf("未知响应代码: %s", queryResp.Rc)
		return data, fmt.Errorf("响应错误，请稍后再试")
	}
}

func (l *LawsuitQueryService) QueryLimitHighList(reqData request.LawsuitQueryReq) (data []response.LimitHightDetail, err error) {
	baseURL := config.ConfigData.LawsuitQuery.LimitHightURL
	appCode := config.ConfigData.LawsuitQuery.AppCode
	// 创建查询参数
	params := url.Values{}
	params.Add("name", reqData.Name)
	params.Add("idcard_number", reqData.CardNo)
	params.Add("mobile_number", reqData.Mobile)

	// 创建请求
	reqBody := bytes.NewBufferString(params.Encode())
	req, err := http.NewRequest("POST", baseURL, reqBody)
	if err != nil {
		log.Printf("failed 创建请求: %v", err)
		return
	}
	// 设置请求头
	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 {
		log.Printf("failed 发送请求: %v", err)
		return
	}
	defer resp.Body.Close()

	// 读取响应体
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("failed 读取响应体: %v", err)
		return
	}

	var queryResp response.LawsuitLimitHightQueryListResponse
	err = json.Unmarshal(body, &queryResp)
	if err != nil {
		log.Printf("limit hight failed to unmarshal response: %v", err)
		return
	}
	switch queryResp.Code {
	case 200:
		var respData response.LimitHightData
		queryRespBytes, err := json.Marshal(queryResp.Data)
		if err != nil {
			log.Printf("limit hight Marshal Error: %v", err)
			return nil, fmt.Errorf("响应错误，请稍后再试")
		}
		err = json.Unmarshal(queryRespBytes, &respData)
		if err != nil {
			log.Printf("limit hight failed to unmarshal data: %v", err)
			return nil, fmt.Errorf("响应错误，请稍后再试")
		}
		return respData.CaseList, nil
	case 400:
		return data, nil
	default:
		log.Printf("%s响应错误: %s", params.Encode(), queryResp.Msg)
		return data, fmt.Errorf("请求错误：%s", queryResp.Msg)
	}
}
func (l *LawsuitQueryService) SaveLawsuit(userid uint, reqBody request.LawsuitQueryReq, orderID uint, combinedResponse response.CombinedResponse) (err error) {
	ListRespMarshal, err := json.Marshal(combinedResponse.ListResp)
	if err != nil {
		return err
	}
	SxrRespMarshal, err := json.Marshal(combinedResponse.SxrResp)
	if err != nil {
		return err
	}
	LimitHightRespMarshal, err := json.Marshal(combinedResponse.LimitHightResp)
	if err != nil {
		return err
	}
	err = db.DB.Create(&model.Lawsuit{
		UserID:         userid,
		CardNo:         reqBody.CardNo,
		Name:           reqBody.Name,
		Mobile:         reqBody.Mobile,
		ListResp:       string(ListRespMarshal),
		SxrResp:        string(SxrRespMarshal),
		LimitHightResp: string(LimitHightRespMarshal),
		OrderID:        orderID,
	}).Error
	if err != nil {
		return err
	}
	return
}

func (l *LawsuitQueryService) CheckPayment(userid uint) (payment bool, err error) {
	var lawsuits []model.Lawsuit
	err = db.DB.Where("userid = ?", userid).Order("id desc").Limit(2).Find(&lawsuits).Error
	if err != nil {
		return false, err
	}
	if len(lawsuits) == 0 {
		return true, nil
	}
	checkFields := func(lawsuit model.Lawsuit) bool {
		return (lawsuit.ListResp == "" || lawsuit.ListResp == "null") &&
			(lawsuit.SxrResp == "" || lawsuit.SxrResp == "null") &&
			(lawsuit.LimitHightResp == "" || lawsuit.LimitHightResp == "null")
	}

	if len(lawsuits) == 1 {
		if checkFields(lawsuits[0]) {
			return false, nil
		}
	}

	if len(lawsuits) == 2 {
		if checkFields(lawsuits[0]) && !checkFields(lawsuits[1]) {
			return false, nil
		}
	}

	return true, nil
}
func (a *LawsuitQueryService) LawsuitDataAnalysis(respString string) (data []map[string]interface{}, err error) {
	var resp model.YuShanResponse[[]map[string]interface{}]
	err = json.Unmarshal([]byte(respString), &resp)
	if err != nil {
		log.Printf("Lawsuit Unmarshal error：%v", err)
		return nil, utils.ErrSystemError
	}
	if resp.Retcode == RetCodeSuccess {
		data = resp.Retdata
		return data, nil
	} else if resp.Retcode == RetCodeEmpty {
		log.Printf("Lawsuit resp empty：%s", resp.Retmsg)
		return data, utils.ErrNoRecord
	} else {
		log.Printf("Lawsuit resp error：%s", resp.Retmsg)
		return data, utils.ErrSystemError
	}
}