package ng_cws_client

import (
	"encoding/json"
	"errors"
	"git.sxidc.com/service-supports/cws-sdk/service"
	"git.sxidc.com/service-supports/cws-sdk/service/request"
	"git.sxidc.com/service-supports/cws-sdk/service/response"
	"git.sxidc.com/service-supports/cws-sdk/utils"
	"git.sxidc.com/service-supports/cws-sdk/utils/http_client"
	"git.sxidc.com/service-supports/cws-sdk/utils/request_util"
	"time"
)

var NGCwsClient *http_client.Client
var cwsUrl string
var cwsTimeOut time.Duration

func Init(url string, timeout time.Duration) error {
	if utils.IsStringEmpty(url) {
		return errors.New("未配置CWS地址")
	}

	NGCwsClient = http_client.New()
	cwsTimeOut = timeout
	cwsUrl = url
	return nil
}

func Destroy() {
	http_client.Destroy(NGCwsClient)
}

func StartWorkFlowByBusinessType(reqParams *request.StartWorkFlowByBusinessTypeRequest) (string, error) {
	//根据业务类型获取流程模型ID
	workflowTemplateId, err := getWorkTemplateInfoByBusinessTypeApi(reqParams.BusinessType, reqParams.TenantID)
	if err != nil {
		return "", err
	}
	if utils.IsStringEmpty(workflowTemplateId) {
		return "", errors.New("该业务类型未配置流程")
	}

	//发起流程前校验 获取人员组织信息
	customStructureInfo, err := LaunchWorkflowPrepare(&request.LaunchWorkflowPrepareParams{
		WorkflowTemplateID: workflowTemplateId,
		CreateUserID:       reqParams.CreateUserID,
		TenantID:           reqParams.TenantID,
	})
	if err != nil {
		return "", err
	}

	jsonBytes, err := json.Marshal(reqParams.Data)
	if err != nil {
		return "", err
	}
	businessEntityObjectStr := string(jsonBytes)

	workflowId, err := StartWorkflow(&request.StartWorkflowRequest{
		WorkflowTemplateID:   workflowTemplateId,
		LaunchUserName:       reqParams.LaunchUserName,
		Matter:               reqParams.Matter,
		BusinessEntityObject: businessEntityObjectStr,
		BusinessObject:       businessEntityObjectStr,
		UserStructureID:      customStructureInfo.ID,
		CreateUserID:         reqParams.CreateUserID,
		TenantID:             reqParams.TenantID,
	})
	if err != nil {
		return "", err
	}

	return workflowId, nil

}

func StartWorkFlowWithoutPrepareByBusinessType(reqParams *request.StartWorkFlowWithoutPrepareByBusinessTypeRequest) (string, error) {
	//根据业务类型获取流程模型ID
	workflowTemplateId, err := getWorkTemplateInfoByBusinessTypeApi(reqParams.BusinessType, reqParams.TenantID)
	if err != nil {
		return "", err
	}
	if utils.IsStringEmpty(workflowTemplateId) {
		return "", errors.New("该业务类型未配置流程")
	}

	jsonBytes, err := json.Marshal(reqParams.Data)
	if err != nil {
		return "", err
	}
	businessEntityObjectStr := string(jsonBytes)

	workflowId, err := StartWorkflow(&request.StartWorkflowRequest{
		WorkflowTemplateID:   workflowTemplateId,
		LaunchUserName:       reqParams.LaunchUserName,
		Matter:               reqParams.Matter,
		BusinessEntityObject: businessEntityObjectStr,
		BusinessObject:       businessEntityObjectStr,
		UserStructureID:      reqParams.UserStructureID,
		CreateUserID:         reqParams.CreateUserID,
		TenantID:             reqParams.TenantID,
		ChoiceApproveInfos:   reqParams.ChoiceApproveInfos,
	})
	if err != nil {
		return "", err
	}

	return workflowId, nil
}

func StartWorkflowTemplate(reqParams *request.StartWorkflowTemplateRequest) (string, error) {
	if utils.IsStringEmpty(cwsUrl) {
		return "", errors.New("未配置CWS地址")
	}

	//发起流程前校验 获取人员组织信息
	customStructureInfo, err := LaunchWorkflowTemplatePrepare(&request.LaunchWorkflowTemplatePrepareParams{
		StructureRootID: reqParams.StructureRootID,
		CreateUserID:    reqParams.CreateUserID,
		TenantID:        reqParams.TenantID,
	})
	if err != nil {
		return "", err
	}

	jsonBytes, err := json.Marshal(reqParams.Data)
	if err != nil {
		return "", err
	}
	businessEntityObjectStr := string(jsonBytes)

	reqJsonParams := &request.StartWorkflowTemplateRequest{
		StructureRootID:      reqParams.StructureRootID,
		WorkflowTemplateName: reqParams.WorkflowTemplateName,
		Process:              reqParams.Process,
		LaunchUserName:       reqParams.LaunchUserName,
		Matter:               reqParams.Matter,
		BusinessEntityObject: businessEntityObjectStr,
		BusinessObject:       businessEntityObjectStr,
		UserStructureID:      customStructureInfo.ID,
		CreateUserID:         reqParams.CreateUserID,
		TenantID:             reqParams.TenantID,
	}
	if err != nil {
		return "", err
	}

	requestJson, err := json.Marshal(reqJsonParams)
	if err != nil {
		return "", err
	}
	postResponse, err := NGCwsClient.NewRequest(http_client.WithNewRequestTimeout(cwsTimeOut)).
		Post(cwsUrl+service.StartWorkFlowTemplateMethodName, requestJson)
	if err != nil {
		return "", err
	}

	resp := new(response.InfoResponse[string])
	err = postResponse.Json(resp)
	if err != nil {
		return "", err
	}
	if !resp.Success {
		return "", errors.New(resp.Msg)
	}

	return resp.Info, nil
}

func StartWorkflow(reqParams *request.StartWorkflowRequest) (string, error) {
	if utils.IsStringEmpty(cwsUrl) {
		return "", errors.New("未配置CWS地址")
	}

	reqMap := request_util.StructToMap(reqParams)
	for nodeID, userIDs := range reqParams.ChoiceApproveInfos {
		reqMap[nodeID] = userIDs
	}

	requestJson, err := json.Marshal(reqMap)
	if err != nil {
		return "", err
	}
	postResponse, err := NGCwsClient.NewRequest(http_client.WithNewRequestTimeout(cwsTimeOut)).
		Post(cwsUrl+service.StartWorkFlowMethodName, requestJson)
	if err != nil {
		return "", err
	}

	resp := new(response.InfoResponse[string])
	err = postResponse.Json(resp)
	if err != nil {
		return "", err
	}
	if !resp.Success {
		return "", errors.New(resp.Msg)
	}

	return resp.Info, nil
}

func LaunchWorkflowTemplatePrepare(reqParams *request.LaunchWorkflowTemplatePrepareParams) (*response.CustomStructureInfo, error) {
	requestJson, err := json.Marshal(reqParams)
	if err != nil {
		return nil, err
	}
	postResponse, err := NGCwsClient.NewRequest(http_client.WithNewRequestTimeout(cwsTimeOut)).
		Post(cwsUrl+service.StartWorkFlowTemplatePrepareMethodName, requestJson)
	if err != nil {
		return nil, err
	}

	resp := new(response.InfosResponse[response.PrepareInfo])
	err = postResponse.Json(resp)
	if err != nil {
		return nil, err
	}
	if !resp.Success {
		return nil, errors.New(resp.Msg)
	}
	customStructureInfo := &response.CustomStructureInfo{}
	for _, info := range resp.Infos {
		if info.ID == "userStructureId" {
			customStructureInfo.ID = info.Options[0].Value
			break
		}
	}

	return customStructureInfo, nil
}

func LaunchWorkflowPrepare(reqParams *request.LaunchWorkflowPrepareParams) (*response.CustomStructureInfo, error) {
	resp, err := launchWorkflowPrepareApi(reqParams)
	if err != nil {
		return nil, err
	}
	customStructureInfo := &response.CustomStructureInfo{}
	for _, info := range resp.Infos {
		if info.ID == "userStructureId" {
			customStructureInfo.ID = info.Options[0].Value
			break
		}
	}

	return customStructureInfo, nil
}

func LaunchWorkflowByBusinessTypePrepare(tenantID string, businessType string, createUserID string) ([]response.PrepareInfo, error) {
	//根据业务类型获取流程模型ID
	workflowTemplateId, err := getWorkTemplateInfoByBusinessTypeApi(businessType, tenantID)
	if err != nil {
		return nil, err
	}
	if utils.IsStringEmpty(workflowTemplateId) {
		return nil, errors.New("该业务类型未配置流程")
	}

	//发起流程前校验 获取人员组织信息
	resp, err := launchWorkflowPrepareApi(&request.LaunchWorkflowPrepareParams{
		WorkflowTemplateID: workflowTemplateId,
		CreateUserID:       createUserID,
		TenantID:           tenantID,
	})
	if err != nil {
		return nil, err
	}

	return resp.Infos, nil
}