package wechat

import (
	"context"
	model "dashoo.cn/micro/app/model/workflow"
	baseSrv "dashoo.cn/micro/app/service/base"
	contractSrv "dashoo.cn/micro/app/service/contract"
	custServer "dashoo.cn/micro/app/service/cust"
	"dashoo.cn/micro/app/service/dingtalk_log"
	platServer "dashoo.cn/micro/app/service/plat"
	projService "dashoo.cn/micro/app/service/proj"
	workService "dashoo.cn/micro/app/service/work"
	workflowServer "dashoo.cn/micro/app/service/workflow"
	dingContext "dashoo.cn/opms_libary/plugin/dingtalk/context"
	"dashoo.cn/opms_libary/plugin/dingtalk/message"
	WXwork "dashoo.cn/opms_libary/plugin/wechat/work"
	"database/sql"
	"fmt"
	"github.com/gogf/gf/os/glog"
	"github.com/gogf/gf/util/gconv"
)

type WeChatHandler struct{}

// CallBack 企业微信事件回调
// 日程相关详情参照文档：https://open.dingtalk.com/document/orgapp/schedule-event
// 审批相关详情参照文档：https://open.dingtalk.com/document/orgapp/approval-events
func (h *WeChatHandler) Callback(ctx context.Context, req *WXwork.SysApprovalChangeMessage, rsp *message.Reply) error {
	// 记录日志
	dingtalk_log.Create(ctx, "20", gconv.String(req))

	switch req.Event.Text {
	case WXwork.SysApprovalChange:
		h.handleSysApprovalChange(ctx, req)
		return nil
	}
	return nil
}

// 验证回调参数
func (h *WeChatHandler) handleCheckUrl(msg *message.MixMessage) string {
	fmt.Println(msg)
	return "success"
}

// 处理审批实例回调
func (h *WeChatHandler) handleSysApprovalChange(ctx context.Context, req *WXwork.SysApprovalChangeMessage) string {
	fmt.Println(req)

	msg := &message.MixMessage{
		EventType:         WXwork.SysApprovalChange,
		ProcessInstanceId: req.ApprovalInfo.SpNo.Text,
		CorpId:            req.AgentID.Text,
		CreateTime:        req.ApprovalInfo.ApplyTime.Text,
		FinishTime:        req.CreateTime.Text,
		Title:             req.ApprovalInfo.SpName.Text,
		ProcessType:       "",
		StaffId:           "",
		Url:               "",
		Result:            "",
		ProcessCode:       req.ApprovalInfo.TemplateId.Text,
		Remark:            "",
	}
	switch req.ApprovalInfo.SpStatus.Text {
	case "1":
		return ""
	case "2":
		msg.ProcessType = "finish"
		msg.Result = "agree"
	case "3":
		msg.ProcessType = "finish"
		msg.Result = "refuse"
	case "4", "6":
		msg.ProcessType = "terminate"
		msg.Result = "refuse"
	default:
		return ""
	}
	fmt.Println(msg)

	// 构造访问服务
	s, err := workflowServer.NewFlowService(ctx)
	if err != nil {
		glog.Error(err)
		return err.Error()
	}
	// 获取审批实例数据
	instance, err := s.GetWorkflowInstance(req.ApprovalInfo.SpNo.Text)
	if err != nil {
		if err == sql.ErrNoRows {
			glog.Error("无匹配的审批实例")
			return "无匹配的审批实例"
		}
		glog.Error(err)
		return err.Error()
	}
	if instance == nil {
		return "无匹配的审批实例"
	}
	// 处理实例数据（不需要企业微信审批实例参数）
	switch instance.BizType {
	case model.CustomerReceive:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := custServer.NewCustomerService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.AssignCustomerRequestApproval(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.CustomerPublic:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := custServer.NewCustomerService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.MoveToPublicApproval(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.CustomerTrans:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := custServer.NewCustomerService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.TransCustomerApproval(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ContractInvoice:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			err = contractSrv.InvoiceApplyApproval(ctx, instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ContractCreate:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			err = contractSrv.ContractApplyApproval(ctx, instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.DistProxyCreate:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			err = baseSrv.ApprovalProxyCreate(ctx, instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.DistToProxy:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			err = baseSrv.ApprovalDistToProxy(ctx, instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.DistProxyRenew:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			err = baseSrv.ApprovalDistRenew(ctx, instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.DistToDist:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			err = baseSrv.ApprovalDistToDist(ctx, instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.WorkOrderCreate:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := workService.NewOrderService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.WorkOrderNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.DeliverOrderCreate:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := workService.NewDeliverOrderService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.DeliverOrderNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ProjectCreate:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := projService.NewBusinessService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.BusinessCreatedNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ProjectUpGrade:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := projService.NewBusinessService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.BusinessUpgradeNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ProjectDownGrade:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := projService.NewBusinessService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.BusinessDowngradeNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ProjectTransfer:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := projService.NewBusinessService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.BusinessTransferNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ProjectToReserve:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := projService.NewBusinessService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.ConvertToReserveNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.PlatTaskApproval:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := platServer.NewTaskService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.AddTaskApproval(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.BidCloseLoop:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := custServer.NewCustCustomerBidRecordService(ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.BidCloseLoopApproval(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	}

	// 以下的代码需要调用企业微信接口查询数据，并且以下接口需要审批实例的数据
	//// 获取企业微信数据
	//resp, err := s.GetProcessInstanceDetail(msg.ProcessInstanceId)
	//if err != nil {
	//	glog.Error(err)
	//	return err.Error()
	//}
	//if resp.Success == "false" {
	//	return "fail"
	//}
	////按照类型处理数据（不需要企业微信审批实例参数）
	//switch instance.BizType {
	//case model.CustomerReceive:
	//	if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
	//		//srv.Handle(instance, msg, resp)
	//	}

	return "success"
}

// 处理审批任务回调
func (h *WeChatHandler) handleBpmsTaskChange(msg *message.MixMessage, ctx *dingContext.Context) string {
	fmt.Println(msg)

	// TODO 目前审批任务无处理逻辑
	//// 本系统数据库操作
	//s, err := platServer.NewScheduleService(ctx)
	//if err != nil {
	//	glog.Error(err)
	//	return err.Error()
	//}
	//// 回填数据
	//err = s.SaveByDingEvent(msg)
	//if err != nil {
	//	glog.Error(err)
	//	return err.Error()
	//}
	return "success"
}