package controllers

import (
	"encoding/json"
	contractReq "hongze/hongze_mobile_admin/models/request/contract"
	contractResp "hongze/hongze_mobile_admin/models/response/contract"
	"hongze/hongze_mobile_admin/models/tables/contract"
	"hongze/hongze_mobile_admin/models/tables/contract_approval"
	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
	contractService "hongze/hongze_mobile_admin/services/contract"
	"hongze/hongze_mobile_admin/utils"
	"rdluck_tools/paging"
	"strings"
)

//合同模块
type ContractCommon struct {
	BaseAuth
}

// @Title 上传签回附件
// @Description 上传签回附件接口
// @Param	request	body contract.UploadCheckBackFileReq true "type json string"
// @Success Ret=200 上传成功
// @router /upload_check_back_file [get]
func (this *ContractCommon) UploadCheckBackFile() {
	var req contractReq.UploadCheckBackFileReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
		return
	}
	//合同编号
	if req.ContractId <= 0 {
		this.FailWithMessage("请传入合同编号！", "请传入合同编号")
		return
	}

	if req.FileUrl == "" {
		this.FailWithMessage("请先上传附件！", "请先上传附件")
		return
	}
	err = contractService.UploadCheckBackFile(req.ContractId, req.FileUrl, this.AdminWx)

	this.OkWithMessage("上传成功")
}

// @Title 获取合同详情
// @Description 获取合同详情接口
// @Param   ContractId   query   int  true       "合同id"
// @Success 200 {object} contract.ContractDetailResp
// @router /detail [get]
func (this *ContractCommon) Detail() {
	//合同类型、产品类型、合同状态、更新时间、所选销售
	//关键字：合同编号、客户名称，社会信用码
	contractId, _ := this.GetInt("ContractId")
	//合同id
	if contractId <= 0 {
		this.FailWithMessage("合同id必传！", "合同id必传！")
		return
	}
	contractInfo, err := contractService.GetContractDetail(contractId)
	if err != nil {
		this.FailWithMessage("获取合同详情失败！", "获取合同详情失败,ERR:"+err.Error())
		return
	}

	contractInfo.StartDateStr = contractInfo.StartDate.Format(utils.FormatDate)
	contractInfo.EndDateStr = contractInfo.EndDate.Format(utils.FormatDate)
	contractInfo.ModifyTimeStr = contractInfo.ModifyTime.Format(utils.FormatDateTime)
	contractInfo.CreateTimeStr = contractInfo.CreateTime.Format(utils.FormatDateTime)

	//审批流
	flowNodeListResp := make([][]contract_approval_record.ContractApprovalRecord, 0)

	//审批操作权限，上传签回文件权限
	var contractOpButton contractResp.OpButton

	//查询最近一次审批单信息
	lastApprovalInfo, err := contract_approval.GetLastContractApprovalByContractId(contractInfo.ContractId, "contract")
	if err != nil {
		if err.Error() != utils.NotEmpty() {
			this.FailWithMessage("获取最近一次审批单信息失败！", "获取最近一次审批单信息失败,ERR:"+err.Error())
			return
		}
	}
	if lastApprovalInfo != nil {
		flowNodeMap := make(map[int][]contract_approval_record.ContractApprovalRecord, 0)
		//审批流
		approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalId(lastApprovalInfo.ContractApprovalId)
		if err != nil {
			this.FailWithMessage("获取审批失败！", "获取审批失败，Err:"+err.Error())
			return
		}
		keySort := make([]int, 0)
		for _, approvalRecord := range approvalRecordList {
			//如果当前节点正好是该节点，同时审批单状态是待审批状态，然后当前账号又有权限，该账号也正是审批人，那么允许审批操作
			if lastApprovalInfo.CurrNodeId == approvalRecord.NodeId && lastApprovalInfo.Status == "待审批" {
				if this.AdminWx.AdminId == approvalRecord.ApproveUserId && approvalRecord.NodeType == "check" {
					contractOpButton.Approval = true
				}
			}
			if tmpFlowNodeList, ok := flowNodeMap[approvalRecord.NodeId]; ok {
				flowNodeMap[approvalRecord.NodeId] = append(tmpFlowNodeList, *approvalRecord)
			} else {
				tmpFlowNodeList := make([]contract_approval_record.ContractApprovalRecord, 1)
				tmpFlowNodeList[0] = *approvalRecord
				flowNodeMap[approvalRecord.NodeId] = tmpFlowNodeList

				keySort = append(keySort, approvalRecord.NodeId)
			}
		}
		for _, key := range keySort {
			flowNodeListResp = append(flowNodeListResp, flowNodeMap[key])
		}

		uploadStatus := []string{"已审批", "已签回"}
		if this.AdminWx.RoleTypeCode == utils.ROLE_TYPE_CODE_COMPLIANCE && strings.Contains(strings.Join(uploadStatus, ","), contractInfo.Status) {
			contractOpButton.UploadFile = true
		}

		//作废权限
		if (this.AdminWx.RoleTypeCode == utils.ROLE_TYPE_CODE_COMPLIANCE || this.AdminWx.AdminId == contractInfo.SellerId) && contractInfo.Status == "已审批" {
			contractOpButton.Invalid = true
		}
	}
	resp := contractResp.ContractDetailResp{
		ContractDetail: contractInfo,
		FlowNodeList:   flowNodeListResp,
		OpButton:       contractOpButton,
	}
	this.OkDetailed(resp, "获取成功")
}

// @Title 根据客户名称获取已存在合同系统中客户名称列表
// @Description 获取合同详情接口
// @Param   CompanyName   query   string  true       "客户名称"
// @Param   Status   query   string  true       "合同状态"
// @Success 200 {object} []string
// @router /company_list [get]
func (this *ContractCommon) CompanyList() {
	companyName := this.GetString("CompanyName")
	//合同id
	if companyName == "" {
		this.FailWithMessage("客户名称必传！", "客户名称必传！")
		return
	}
	status := this.GetString("Status")
	companyNameList := make([]string, 0)
	list, err := contract.GetCompanyNameList(companyName, status)
	if err != nil {
		this.FailWithMessage("获取客户名称列表失败！", "获取客户名称列表失败,ERR:"+err.Error())
		return
	}

	for _, v := range list {
		companyNameList = append(companyNameList, v.CompanyName)
	}

	this.OkDetailed(companyNameList, "获取成功")
}

// @Title 合同列表
// @Description 合同列表接口
// @Param   ContractType   query   string  false       "合同类型，枚举值：'新签合同','续约合同','补充协议'"
// @Param   ContractStatus   query   string  false       "合同状态，枚举值：'待提交','待审批','已撤回','已审批','已驳回','已作废'"
// @Param   ProductId   query   int  false       "客户类型：传0或者不传为当前账号权限,1 代表是：ficc；2 代表是：权益"
// @Param   ModifyStartTime   query   string  false       "服务更新时间的选择开始时间，格式：2021-05-23 00:00:00"
// @Param   ModifyEndTime   query   string  false       "服务更新时间的选择结束时间，格式：2021-05-26 23:59:59"
// @Param   SellerId   query   string  false       "选择的销售id"
// @Param   Keyword   query   string  false       "搜索关键字"
// @Success 200 {object} contract.ContractListResp
// @router /list [get]
func (this *ContractCommon) List() {
	//合同类型、产品类型、合同状态、更新时间、所选销售
	//关键字：合同编号、客户名称，社会信用码
	contractType := this.GetString("ContractType")
	contractStatus := this.GetString("ContractStatus")
	productId, _ := this.GetInt("ProductId")
	modifyStartTime := this.GetString("ModifyStartTime")
	modifyEndTime := this.GetString("ModifyEndTime")
	sellerIds := this.GetString("SellerId")
	keyword := this.GetString("Keyword")

	condition := ""
	pars := make([]interface{}, 0)
	//如果不是超管或者合规，那么只能查看自己的合同
	condition += ` AND seller_id = ? `
	pars = append(pars, this.AdminWx.AdminId)
	//合同类型、、更新时间、所选销售
	//关键字：合同编号、客户名称，社会信用码
	if contractType != "" {
		condition += ` AND contract_type = ? `
		pars = append(pars, contractType)
	}
	//合同状态
	if contractStatus != "" {
		condition += ` AND status = ? `
		pars = append(pars, contractStatus)
	}
	//产品类型
	if productId > 0 {
		condition += ` AND product_id = ? `
		pars = append(pars, productId)
	}
	//所选销售
	if sellerIds != "" {
		condition += ` AND seller_id IN (` + sellerIds + `) `
	}
	//更新开始时间
	if modifyStartTime != "" {
		condition += ` AND modify_time >= ? `
		pars = append(pars, modifyStartTime)
	}
	//更新结束时间
	if modifyEndTime != "" {
		condition += ` AND modify_time <= ? `
		pars = append(pars, modifyEndTime)
	}
	//关键字
	if keyword != "" {
		condition += ` AND (contract_code LIKE '%` + keyword + `%' OR company_name LIKE '%` + keyword + `%' OR credit_code LIKE '%` + keyword + `%' ) `
	}

	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	total, err := contract.GetContractListCount(condition, pars)
	if err != nil {
		this.FailWithMessage("获取失败", "获取数据总数失败，Err:"+err.Error())
		return
	}

	list, err := contract.GetContractList(condition, pars, startSize, pageSize)
	if err != nil {
		this.FailWithMessage("获取合同列表失败", "获取合同列表失败，Err:"+err.Error())
		return
	}

	page := paging.GetPaging(currentIndex, pageSize, total)

	this.OkDetailed(contractResp.ContractListResp{
		List:   list,
		Paging: page,
	}, "获取成功")
}