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"
	"strconv"
	"strings"
)

//合同审批模块
type ContractApprovalCommon struct {
	BaseAuth
}

// @Title 审批单列表
// @Description 审批单列表接口
// @Param   ContractType   query   string  false       "合同类型，枚举值：'新签合同','续约合同','补充协议'"
// @Param   Status   query   string  false       "合同状态，枚举值：'待审批','已审批','已驳回','已撤回'"
// @Param   ProductId   query   int  false       "客户类型：传0或者不传为当前账号权限,1 代表是：ficc；2 代表是：权益"
// @Param   SellerId   query   string  false       "选择的销售id"
// @Param   Keyword   query   string  false       "搜索关键字"
// @Param   ModifyStartTime   query   string  false       "服务更新时间的选择开始时间，格式：2021-05-23 00:00:00"
// @Param   ModifyEndTime   query   string  false       "服务更新时间的选择结束时间，格式：2021-05-26 23:59:59"
// @Success 200 {object} contract.ContractApprovalListResp
// @router /list [get]
func (this *ContractApprovalCommon) List() {
	sysUser := this.AdminWx

	//合同类型、产品类型、合同状态、更新时间、所选销售
	//关键字：合同编号、客户名称，社会信用码
	contractType := this.GetString("ContractType")
	status := this.GetString("Status")
	productId, _ := this.GetInt("ProductId")
	sellerIds := this.GetString("SellerId")
	keyword := this.GetString("Keyword")
	modifyStartTime := this.GetString("ModifyStartTime")
	modifyEndTime := this.GetString("ModifyEndTime")

	childCondition := ""
	condition := ""
	childPars := make([]interface{}, 0)
	pars := make([]interface{}, 0)
	////如果不是超管或者合规，那么只能查看自己的合同
	//if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_RAI_ADMIN { //权益管理员
	//	condition += ` AND c.product_id = ? `
	//	pars = append(pars, 2)
	//} else if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN { //ficc管理员
	//	condition += ` AND c.product_id = ? `
	//	pars = append(pars, 1)
	//} else {
	//	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_COMPLIANCE && sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
	//		condition += ` AND c.seller_id = ? `
	//		pars = append(pars, sysUser.AdminId)
	//	}
	//}

	condition += ` AND (c.seller_id = ? or d.approve_user_id = ?)`
	pars = append(pars, sysUser.AdminId, sysUser.AdminId)

	//合同类型、、更新时间、所选销售
	//关键字：合同编号、客户名称，社会信用码
	if contractType != "" {
		condition += ` AND c.contract_type = ? `
		pars = append(pars, contractType)
	}
	//审批状态
	if status != "" {
		//childCondition += ` AND status = ? `
		//childPars = append(childPars, status)

		if status == "已审批" {
			condition += ` AND c.status in ("已审批","已驳回")  `
		} else {
			condition += ` AND c.status = ? `
			pars = append(pars, status)
		}
	} else {
		//childCondition += ` AND status != "已撤回" `

		condition += ` AND c.status not in ("已撤回","待提交")  `
	}
	//产品类型
	if productId > 0 {
		condition += ` AND c.product_id = ? `
		pars = append(pars, productId)
	}
	//所选销售
	if sellerIds != "" {
		condition += ` AND c.seller_id IN (` + sellerIds + `) `
	}
	//更新开始时间

	//更新开始时间
	if modifyStartTime != "" {
		condition += ` AND a.modify_time >= ? `
		pars = append(pars, modifyStartTime)
	}
	//更新结束时间
	if modifyEndTime != "" {
		condition += ` AND a.modify_time <= ? `
		pars = append(pars, modifyEndTime)
	}
	//关键字
	if keyword != "" {
		condition += ` AND (c.contract_code LIKE '%` + keyword + `%' OR c.company_name LIKE '%` + keyword + `%' OR c.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_approval.GetContractApprovalListCount(condition, pars)
	total, err := contract_approval.GetContractApprovalListCount(childCondition, condition, childPars, pars)
	if err != nil {
		this.FailWithMessage("获取失败", "获取数据总数失败，Err:"+err.Error())
		return
	}

	list, err := contract_approval.GetContractApprovalList(childCondition, condition, childPars, pars, startSize, pageSize)
	if err != nil {
		this.FailWithMessage("获取审批列表失败！", "获取审批列表失败，Err:"+err.Error())
		return
	}

	if len(list) > 0 {
		contractApprovalIdSlice := make([]string, 0)
		for i := 0; i < len(list); i++ {
			contractApprovalIdSlice = append(contractApprovalIdSlice, strconv.Itoa(list[i].ContractApprovalId))
		}
		contractApprovalIdStr := strings.Join(contractApprovalIdSlice, ",")

		//获取审批流列表数据
		contractApprovalRecordList, err := contract_approval_record.GetContractApprovalRecordList(contractApprovalIdStr, sysUser.AdminId)
		if err != nil {
			this.FailWithMessage("获取审批列表失败！", "获取审批列表失败，Err:"+err.Error())
			return
		}
		contractApprovalRecordMap := make(map[int]*contract_approval_record.ContractApprovalRecord)
		for i := 0; i < len(contractApprovalRecordList); i++ {
			contractApprovalRecordMap[contractApprovalRecordList[i].ContractApprovalId] = contractApprovalRecordList[i]
		}

		for i := 0; i < len(list); i++ {
			item := list[i]
			list[i].StartDateStr = item.StartDate.Format(utils.FormatDate)
			list[i].EndDateStr = item.EndDate.Format(utils.FormatDate)
			list[i].CreateTimeStr = item.CreateTime.Format(utils.FormatDateTime)
			list[i].ModifyTimeStr = item.ModifyTime.Format(utils.FormatDateTime)

			//list[i].ContractInfo = contractDetail
			//校验最新审批流数据
			//if contractApprovalRecord, has := contractApprovalRecordMap[item.ContractApprovalId]; has {
			//	//审批流id
			//	list[i].ContractApprovalRecordId = contractApprovalRecord.ContractApprovalRecordId
			//	//审批时间
			//	list[i].ApproveTime = contractApprovalRecord.ApproveTime
			//	list[i].ApproveTimeStr = contractApprovalRecord.ApproveTime.Format(utils.FormatDateTime)
			//
			//	////判断是否处于待审批状态
			//	//if contractApprovalRecord.Status == "待审批" {
			//	//	//如果不是审批者，那么不能审批操作
			//	//	if contractApprovalRecord.NodeType != "check" {
			//	//		continue
			//	//	}
			//	//	//如果没有指定审批人的话
			//	//	if contractApprovalRecord.ApproveUserId <= 0 {
			//	//		//判断是否与审批角色一致，如果一致，那么允许操作审批
			//	//		if contractApprovalRecord.ApproveRoleTypeCode == sysUser.RoleTypeCode {
			//	//			list[i].CanApprovalButton = true
			//	//		}
			//	//	} else if contractApprovalRecord.ApproveUserId == sysUser.AdminId {
			//	//		//如果指定审批人就是自己的话，那么操作审批
			//	//		list[i].CanApprovalButton = true
			//	//	}
			//	//}
			//}

			//合同状态（突然说要改成展示合同状态，那就根据业务需求，改成返回：合同状态咯）
			list[i].Status = item.ContractStatus
		}
	}

	page := paging.GetPaging(currentIndex, pageSize, total)
	this.OkDetailed(contractResp.ContractApprovalListResp{
		List:   list,
		Paging: page,
	}, "获取成功")
}

// @Title 审批单详情
// @Description 审批单详情接口
// @Param   ContractApprovalId   query   int  false       "审批单id"
// @Success 200 {object} contract.ContractDetailResp
// @router /detail [get]
func (this *ContractApprovalCommon) Detail() {
	//审批单id
	contractApprovalId, _ := this.GetInt("ContractApprovalId")

	//审批单详情
	contractApprovalInfo, err := contract_approval.GetContractApprovalById(contractApprovalId)
	if err != nil {
		this.FailWithMessage("获取审批单失败！", "获取审批单失败，Err:"+err.Error())
		return
	}
	var contractDetail *contract.ContractDetail
	jsonErr := json.Unmarshal([]byte(contractApprovalInfo.ContractDetail), contractDetail)
	if jsonErr != nil {
		this.FailWithMessage("审批合同数据转换失败！", "审批合同数据转换失败，Err:"+jsonErr.Error())
		return
	}

	//合同详情
	contractInfo, err := contract.GetContractById(contractApprovalInfo.ContractId)
	if err != nil {
		this.FailWithMessage("获取合同详情失败！", "获取合同详情失败，Err:"+err.Error())
		return
	}

	//替换快照数据
	contractDetail.Status = contractInfo.Status
	contractDetail.FileUrl = contractInfo.FileUrl
	contractDetail.CheckBackFileUrl = contractInfo.CheckBackFileUrl

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

	//审批流
	approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalId(contractApprovalId)
	if err != nil {
		this.FailWithMessage("获取审批失败！", "获取审批失败，Err:"+err.Error())
		return
	}
	flowNodeMap := make(map[int][]contract_approval_record.ContractApprovalRecord, 0)
	keySort := make([]int, 0)
	for _, approvalRecord := range approvalRecordList {
		//如果当前节点正好是该节点，同时审批单状态是待审批状态，然后当前账号又有权限，该账号也正是审批人，那么允许审批操作
		if contractApprovalInfo.CurrNodeId == approvalRecord.NodeId && contractApprovalInfo.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)
		}
	}
	flowNodeListResp := make([][]contract_approval_record.ContractApprovalRecord, 0)
	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: contractDetail,
		FlowNodeList:   flowNodeListResp,
		OpButton:       contractOpButton,
	}
	this.OkDetailed(resp, "获取成功")
}

// @Title 驳回审批
// @Description 驳回审批接口
// @Param	request	body contract.RejectReq true "type json string"
// @Success Ret=200 驳回成功
// @router /reject [post]
func (this *ContractApprovalCommon) Reject() {
	var req contractReq.RejectReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
		return
	}
	//合同id编号
	contractId := req.ContractId
	if contractId <= 0 {
		this.FailWithMessage("请传入合同编号！", "请传入合同编号！")
		return
	}

	//数据校验
	contractInfo, approvalInfo, approvalRecord, err := contractService.CheckApproveAuth(contractId, this.AdminWx)
	if err != nil {
		this.FailWithMessage("驳回审批失败！", "驳回审批失败，Err:"+err.Error())
		return
	}
	err = contractService.Reject(contractInfo, approvalInfo, approvalRecord, this.AdminWx, req.Remark)
	if err != nil {
		this.FailWithMessage("驳回审批失败！", "驳回审批失败，Err:"+err.Error())
		return
	}
	this.OkWithMessage("驳回成功")
}

// @Title 处理审批单
// @Description 处理审批单
// @Param	request	body contract.ApprovedReq true "type json string"
// @Success Ret=200 申请成功
// @router /approved [post]
func (this *ContractApprovalCommon) Approved() {
	var req contractReq.ApprovedReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
		return
	}
	//合同id编号
	contractId := req.ContractId
	if contractId <= 0 {
		this.FailWithMessage("请传入合同编号！", "请传入合同编号！")
		return
	}
	//数据校验
	contractInfo, approvalInfo, approvalRecord, err := contractService.CheckApproveAuth(contractId, this.AdminWx)
	if err != nil {
		this.FailWithMessage("驳回审批失败！", "驳回审批失败，Err:"+err.Error())
		return
	}
	err = contractService.Approved(contractInfo, approvalInfo, approvalRecord, this.AdminWx, req.Remark)
	if err != nil {
		this.FailWithMessage("审核失败！", "审核失败，Err:"+err.Error())
		return
	}
	this.OkWithMessage("审核通过")
}