package allied_creation_cooperation

import (
	"fmt"
	"github.com/linmadan/egglib-go/utils/json"
	"strconv"
	"strings"

	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/log"

	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway"
)

// CooperationContractAdd 创建共创合约
func (gateway HttplibAlliedCreationCooperation) CooperationContractAdd(param ReqCooperationContractAdd) (*DataCooperationContractAdd, error) {
	url := gateway.baseUrL + "/cooperation-contracts"
	method := "POST"
	req := gateway.CreateRequest(url, method)
	log.Logger.Debug("向业务模块请求数据：创建共创合约。", map[string]interface{}{
		"api":   method + ":" + url,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求创建共创合约失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取创建共创合约失败：%w", err)
	}
	log.Logger.Debug("获取业务模块请求数据：创建共创合约。", map[string]interface{}{
		"result": strings.ReplaceAll(string(byteResult), "\n", ""),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析创建共创合约：%w", err)
	}
	var data DataCooperationContractAdd
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// CooperationContractUpdate 更新共创合约
func (gateway HttplibAlliedCreationCooperation) CooperationContractUpdate(param ReqCooperationContractUpdate) (*DataCooperationContractUpdate, error) {
	url := gateway.baseUrL + "/cooperation-contracts/" + strconv.Itoa(param.CooperationContractId)
	method := "PUT"
	req := gateway.CreateRequest(url, method)
	log.Logger.Debug("向业务模块请求数据：更新共创合约。", map[string]interface{}{
		"api":   method + ":" + url,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求更新共创合约失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取更新共创合约失败：%w", err)
	}
	log.Logger.Debug("获取业务模块请求数据：更新共创合约。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析更新共创合约：%w", err)
	}
	var data DataCooperationContractUpdate
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// CooperationContractSearch 查询共创合约
func (gateway HttplibAlliedCreationCooperation) CooperationContractSearch(param ReqCooperationContractSearch) (*DataCooperationContractSearch, error) {
	url := gateway.baseUrL + "/cooperation-contracts/search"
	method := "POST"
	req := gateway.CreateRequest(url, method)
	log.Logger.Debug("向业务模块请求数据：查询共创合约。", map[string]interface{}{
		"api":   method + ":" + url,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求查询共创合约失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取查询共创合约失败：%w", err)
	}
	log.Logger.Debug("获取业务模块请求数据：查询共创合约。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析查询共创合约：%w", err)
	}
	var data DataCooperationContractSearch
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// CooperationContractsSearchByUndertaker 根据承接人查询并返回共创项目合约
func (gateway HttplibAlliedCreationCooperation) CooperationContractsSearchByUndertaker(
	param ReqCooperationContractSearchByUndertaker) (*DataCooperationContractSearchByUndertaker, error) {
	url := gateway.baseUrL + "/cooperation-contracts/search-by-undertaker"
	method := "POST"
	req := gateway.CreateRequest(url, method)
	log.Logger.Debug("向业务模块请求数据：根据承接人查询并返回共创项目合约。", map[string]interface{}{
		"api":   method + ":" + url,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求根据承接人查询并返回共创项目合约失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取根据承接人查询并返回共创项目合约失败：%w", err)
	}
	log.Logger.Debug("获取业务模块请求数据：根据承接人查询并返回共创项目合约。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析根据承接人查询并返回共创项目合约：%w", err)
	}
	var data DataCooperationContractSearchByUndertaker
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// CooperationContractRemove 移除共创合约
func (gateway HttplibAlliedCreationCooperation) CooperationContractRemove(param ReqCooperationContractRemove) (*DataCooperationContractRemove, error) {
	url := gateway.baseUrL + "/cooperation-contracts/" + strconv.Itoa(param.CooperationContractId)
	method := "DELETE"
	req := gateway.CreateRequest(url, method)
	log.Logger.Debug("向业务模块请求数据：移除共创合约。", map[string]interface{}{
		"api":   method + ":" + url,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求移除共创合约失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取移除共创合约失败：%w", err)
	}
	log.Logger.Debug("获取业务模块请求数据：移除共创合约。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析移除共创合约：%w", err)
	}
	var data DataCooperationContractRemove
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// CooperationContractList 返回共创合约列表
func (gateway HttplibAlliedCreationCooperation) CooperationContractList(param ReqCooperationContractList) (*DataCooperationContractList, error) {
	url := gateway.baseUrL + "/cooperation-contracts"
	method := "GET"
	req := gateway.CreateRequest(url, method)
	log.Logger.Debug("向业务模块请求数据：返回共创合约列表。", map[string]interface{}{
		"api":   method + ":" + url,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求返回共创合约列表失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取返回共创合约列表失败：%w", err)
	}
	log.Logger.Debug("获取业务模块请求数据：返回共创合约列表。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析返回共创合约列表：%w", err)
	}
	var data DataCooperationContractList
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// CooperationContractGet 返回共创合约详情
func (gateway HttplibAlliedCreationCooperation) CooperationContractGet(param ReqCooperationContractGet) (*DataCooperationContractGet, error) {
	url := gateway.baseUrL + "/cooperation-contracts/" + strconv.Itoa(param.CooperationContractId)
	method := "GET"
	req := gateway.CreateRequest(url, method)
	log.Logger.Debug("向业务模块请求数据：返回共创合约详情。", map[string]interface{}{
		"api":   method + ":" + url,
		"param": param,
	})

	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求返回共创合约详情失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取返回共创合约详情失败：%w", err)
	}
	log.Logger.Debug("获取业务模块请求数据：返回共创合约详情。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析返回共创合约详情：%w", err)
	}
	var data DataCooperationContractGet
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// CooperationContractsBatchOperate 暂停恢复合约
func (gateway HttplibAlliedCreationCooperation) CooperationContractsBatchOperate(param ReqCooperationContractsBatchOperate) (*DataCooperationContractsBatchOperate, error) {
	url := gateway.baseUrL + "/cooperation-contracts/batch-operate"
	method := "POST"
	req := gateway.CreateRequest(url, method)
	log.Logger.Debug("向业务模块请求数据：返回共创合约详情。", map[string]interface{}{
		"api":   method + ":" + url,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求返回共创合约详情失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取返回共创合约详情失败：%w", err)
	}
	log.Logger.Debug("获取业务模块请求数据：返回共创合约详情。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析返回共创合约详情：%w", err)
	}
	var data DataCooperationContractsBatchOperate
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// CooperationContractBatchRemove 批量移除共创合约
func (gateway HttplibAlliedCreationCooperation) CooperationContractBatchRemove(param ReqCooperationContractBatchRemove) (*DataCooperationContractBatchRemove, error) {
	url := gateway.baseUrL + "/cooperation-contracts/batch-remove"
	method := "POST"
	req := gateway.CreateRequest(url, method)
	log.Logger.Debug("向业务模块请求数据：批量移除共创合约。", map[string]interface{}{
		"api":   method + ":" + url,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求移除共创合约失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取移除共创合约失败：%w", err)
	}
	log.Logger.Debug("获取业务模块请求数据：移除共创合约。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析移除共创合约：%w", err)
	}
	var data DataCooperationContractBatchRemove
	err = gateway.GetResponseData(result, &data)
	return &data, err
}