package upcrmservice

import (
	"context"
	"errors"
	"fmt"
	"sort"
	"strings"
	"time"

	"go-common/app/admin/main/up/dao/global"
	"go-common/app/admin/main/up/model"
	"go-common/app/admin/main/up/model/signmodel"
	"go-common/app/admin/main/up/model/upcrmmodel"
	"go-common/app/admin/main/up/service/cache"
	"go-common/app/admin/main/up/util"
	accgrpc "go-common/app/service/main/account/api"
	"go-common/library/log"
	"go-common/library/net/http/blademaster"
	"go-common/library/net/metadata"
	xtime "go-common/library/time"

	"github.com/jinzhu/gorm"
)

// SignUpAuditLogs .
func (s *Service) SignUpAuditLogs(c context.Context, arg *signmodel.SignOpSearchArg) (res *signmodel.SignAuditListReply, err error) {
	return s.mng.SignUpAuditLogs(c, arg)
}

// SignAdd add sign info
func (s *Service) SignAdd(context context.Context, arg *signmodel.SignUpArg) (result signmodel.CommonResponse, err error) {
	if arg == nil {
		log.Error("sign add arg is nil")
		return
	}
	// 处理合同信息
	var contractInfo []*signmodel.SignContractInfoArg
	for _, v := range arg.ContractInfo {
		if v == nil || strings.Trim(v.Filename, " ") == "" {
			continue
		}
		if strings.Trim(v.Filelink, " \n\r") == "" {
			err = model.ErrNoFileLink
			log.Error("no file link for contract, please upload file, arg=%v", arg)
			return
		}
		contractInfo = append(contractInfo, v)
	}
	arg.ContractInfo = contractInfo
	// 从context 里拿后台登录信息
	var bmContext, ok = context.(*blademaster.Context)
	if ok {
		uid, ok := util.GetContextValueInt64(bmContext, "uid")
		if ok {
			arg.AdminID = int(uid)
		}
		name, ok := util.GetContextValueString(bmContext, "username")
		if ok {
			arg.AdminName = name
		}
	}
	log.Info("add sign up, req=%+v, admin id=%d, admin name=%s", arg, arg.AdminID, arg.AdminName)
	// 事物
	tx := s.crmdb.BeginTran(context)
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	// 获取up主基础信息中的分区id
	upInfo, _ := s.crmdb.QueryUpBaseInfo(arg.Mid, "active_tid")
	// 1.先去sign up里插入一条记录，然后获得对应的id
	var dbSignUp signmodel.SignUp
	// 把请求信息制作签约up的db内容
	arg.CopyTo(&dbSignUp)
	if upInfo.ActiveTid != 0 {
		// 把up主的分区id赋值到签约up主信息
		dbSignUp.ActiveTid = int16(upInfo.ActiveTid)
	}
	_, e := s.crmdb.InsertSignUp(tx, &dbSignUp)
	err = e
	if err != nil {
		log.Error("fail to add into sign up db, req=%+v, err=%+v", arg, err)
		return
	}

	log.Info("add sign up ok, new id=%d, next add other info", dbSignUp.ID)
	// 2.把id写入pay/task/contract的sign_id字段中，然后分别将这三种信息插入到数据库
	for _, v := range arg.PayInfo {
		v.SignID = dbSignUp.ID
		v.Mid = dbSignUp.Mid
		if _, err = s.addPayInfo(tx, v); err != nil {
			log.Error("insert payinfo db fail, err=%+v", err)
			break
		}
	}

	for _, v := range arg.TaskInfo {
		v.SignID = dbSignUp.ID
		v.Mid = dbSignUp.Mid
		if _, err = s.addTaskInfo(tx, v); err != nil {
			log.Error("insert payinfo db fail, err=%+v", err)
			break
		}
	}

	for _, v := range arg.ContractInfo {
		v.SignID = dbSignUp.ID
		v.Mid = dbSignUp.Mid
		if _, err = s.addContractInfo(tx, v); err != nil {
			log.Error("insert payinfo db fail, err=%+v", err)
			break
		}
	}
	log.Info("add sign up, new id=%d, all info finish", dbSignUp.ID)
	index := []interface{}{}
	content := map[string]interface{}{
		"new":         arg,
		"old":         nil,
		"change_type": new([]int8),
	}
	// 上报添加的签约日志
	s.AddAuditLog(signmodel.SignUpLogBizID, signmodel.SignUpMidAdd, "新增", int64(arg.AdminID), arg.AdminName, []int64{int64(arg.Mid)}, index, content)
	return
}

// SignUpdate .
func (s *Service) SignUpdate(context context.Context, arg *signmodel.SignUpArg) (result signmodel.CommonResponse, err error) {
	if arg == nil || arg.ID == 0 {
		log.Error("sign up arg is nil")
		return
	}
	// 处理合同信息
	var contractInfo []*signmodel.SignContractInfoArg
	for _, v := range arg.ContractInfo {
		if v == nil || strings.Trim(v.Filename, " ") == "" {
			continue
		}
		if strings.Trim(v.Filelink, " \n\r") == "" {
			err = model.ErrNoFileLink
			log.Error("no file link for contract, please upload file, arg=%v", arg)
			return
		}
		contractInfo = append(contractInfo, v)
	}
	arg.ContractInfo = contractInfo
	// 从context 里拿后台登录信息
	var bmContext, ok = context.(*blademaster.Context)
	if ok {
		uid, ok := util.GetContextValueInt64(bmContext, "uid")
		if ok {
			arg.AdminID = int(uid)
		}
		name, ok := util.GetContextValueString(bmContext, "username")
		if ok {
			arg.AdminName = name
		}
	}
	log.Info("add sign up, req=%+v, admin id=%d, admin name=%s", arg, arg.AdminID, arg.AdminName)
	// 预处理声明参数
	var (
		oriSignUp                                         *signmodel.SignUp
		oriSignPayMap                                     map[int64]*signmodel.SignPay
		oriSignTaskMap                                    map[int64]*signmodel.SignTask
		oriSignContractMap                                map[int64]*signmodel.SignContract
		signPayIDMap, signTaskIDMap, signContractIDMap    map[int64]struct{}
		delSignPayIDs, delSignTaskIDs, delSignContractIDs []int64
		changeType                                        []int8
		signPays                                          []*signmodel.SignPay
		signTasks                                         []*signmodel.SignTask
		signContracts                                     []*signmodel.SignContract
		fields                                            = make(map[int8]struct{})
		signUp                                            = &signmodel.SignUp{}
		oriSignUpArg                                      = new(signmodel.SignUpArg)
	)
	// 从db获取签约信息 、付款信息、任务信息、合同信息
	if oriSignUp, oriSignPayMap, oriSignTaskMap, oriSignContractMap, err = s.crmdb.SignUpID(arg.ID); err != nil {
		log.Error("s.crmdb.SignUpID(%+d) error(%+v)", arg.ID, err)
		return
	}
	if oriSignUp.State == 1 || oriSignUp.State == 100 {
		err = fmt.Errorf("up签约已过期或者已被删除")
		return
	}
	// 把请求参数制作成签约up的db
	arg.CopyTo(signUp)
	// 请求的签约up信息和db的签约up信息做diff, fields包含了修改哪些信息
	signUp.Diff(oriSignUp, fields)
	// 把db内的签约信息制作成请求参数类型数据, 放入上报日志需要
	oriSignUpArg.SignUpBaseInfo.CopyFrom(oriSignUp)
	// 需要更新的付款信息的db id
	signPayIDMap = map[int64]struct{}{}
	// 对比请求的付款信息,diff 出变更的数据
	for _, v := range arg.PayInfo {
		var sp = &signmodel.SignPay{}
		v.CopyTo(sp)
		sp.Diff(oriSignPayMap, fields)
		sp.SignID = arg.ID
		sp.Mid = arg.Mid
		v.SignID = arg.ID
		v.Mid = arg.Mid
		signPays = append(signPays, sp)
		signPayIDMap[v.ID] = struct{}{}
	}
	// 把db内付款信息制作成上报日志需要结构
	for _, v := range oriSignPayMap {
		var pi = &signmodel.SignPayInfoArg{}
		pi.CopyFrom(v)
		pi.SignID = arg.ID
		pi.Mid = arg.Mid
		oriSignUpArg.PayInfo = append(oriSignUpArg.PayInfo, pi)
		if _, ok := signPayIDMap[v.ID]; !ok && v.ID != 0 {
			delSignPayIDs = append(delSignPayIDs, int64(v.ID))
		}
	}
	// 付款信息是否存在删除
	if len(delSignPayIDs) > 0 {
		fields[signmodel.ChangeSignPayHistory] = struct{}{}
	}
	// 需要更新的任务的db id
	signTaskIDMap = map[int64]struct{}{}
	// 对比请求的任务信息,diff 出变更的数据
	for _, v := range arg.TaskInfo {
		var st = &signmodel.SignTask{SignID: arg.ID, Mid: arg.Mid}
		v.CopyTo(st)
		st.Diff(oriSignTaskMap, fields)
		st.SignID = arg.ID
		st.Mid = arg.Mid
		v.SignID = arg.ID
		v.Mid = arg.Mid
		signTasks = append(signTasks, st)
		signTaskIDMap[v.ID] = struct{}{}
	}
	// 把db内任务信息制作成上报日志需要结构
	for _, v := range oriSignTaskMap {
		var ti = &signmodel.SignTaskInfoArg{}
		ti.CopyFrom(v)
		ti.SignID = arg.ID
		ti.Mid = arg.Mid
		oriSignUpArg.TaskInfo = append(oriSignUpArg.TaskInfo, ti)
		if _, ok := signTaskIDMap[v.ID]; !ok && v.ID != 0 {
			delSignTaskIDs = append(delSignTaskIDs, int64(v.ID))
		}
	}
	// 任务是否存在删除
	if len(delSignTaskIDs) > 0 {
		fields[signmodel.ChangeSignTaskHistory] = struct{}{}
	}
	// 需要更新的合同的db id
	signContractIDMap = map[int64]struct{}{}
	// 对比请求的合同信息,diff 出变更的数据
	for _, v := range arg.ContractInfo {
		var sc = &signmodel.SignContract{SignID: arg.ID, Mid: arg.Mid}
		v.CopyTo(sc)
		sc.Diff(oriSignContractMap, fields)
		sc.SignID = arg.ID
		sc.Mid = arg.Mid
		v.SignID = arg.ID
		v.Mid = arg.Mid
		signContracts = append(signContracts, sc)
		signContractIDMap[v.ID] = struct{}{}
	}
	// 把db内合同信息制作成上报日志需要结构
	for _, v := range oriSignContractMap {
		var si = &signmodel.SignContractInfoArg{}
		si.CopyFrom(v)
		si.SignID = arg.ID
		si.Mid = arg.Mid
		oriSignUpArg.ContractInfo = append(oriSignUpArg.ContractInfo, si)
		if _, ok := signContractIDMap[v.ID]; !ok && v.ID != 0 {
			delSignContractIDs = append(delSignContractIDs, int64(v.ID))
		}
	}
	// 合同是否存在删除
	if len(delSignContractIDs) > 0 {
		fields[signmodel.ChangeSignContractHistory] = struct{}{}
	}
	for k := range fields {
		changeType = append(changeType, k)
	}
	if len(changeType) == 0 {
		err = fmt.Errorf("up签约信息暂无修改")
		return
	}
	tx := s.crmdb.BeginTran(context)
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	if _, err = s.crmdb.InsertSignUp(tx, signUp); err != nil {
		log.Error("fail to add into sign up db, req=%+v, err=%+v", arg, err)
		return
	}
	for _, v := range signPays {
		if _, err = s.crmdb.InsertPayInfo(tx, v); err != nil {
			log.Error("insert pay info db fail, err=%+v", err)
			break
		}
	}
	for _, v := range signTasks {
		if _, err = s.crmdb.InsertTaskInfo(tx, v); err != nil {
			log.Error("insert task info db fail, err=%+v", err)
			break
		}
		var (
			init bool
			sth  *signmodel.SignTaskHistory
		)
		if sth, init, err = s.crmdb.GetOrCreateTaskHistory(tx, v); err != nil {
			log.Error("s.crmdb.GetOrCreateTaskHistory, err=%+v", err)
			break
		}
		if !init {
			sth.Attribute = v.Attribute
			sth.TaskCondition = v.TaskCondition
			sth.TaskType = v.TaskType
			if err = s.crmdb.UpSignTaskHistory(tx, sth); err != nil {
				log.Error("s.crmdb.UpSignTaskHistory, err=%+v", err)
				break
			}
		}
	}
	for _, v := range signContracts {
		if _, err = s.crmdb.InsertContractInfo(tx, v); err != nil {
			log.Error("insert contract info db fail, err=%+v", err)
			break
		}
	}
	if _, err = s.crmdb.DelPayInfo(tx, delSignPayIDs); err != nil {
		log.Error("delete task info db fail, err=%+v", err)
		return
	}
	if _, err = s.crmdb.DelTaskInfo(tx, delSignTaskIDs); err != nil {
		log.Error("delete task info db fail, err=%+v", err)
		return
	}
	if _, err = s.crmdb.DelSignContract(tx, delSignContractIDs); err != nil {
		log.Error("delete task info db fail, err=%+v", err)
		return
	}
	index := []interface{}{int64(arg.ID)}
	content := map[string]interface{}{
		"new":         arg,
		"old":         oriSignUpArg,
		"change_type": changeType,
	}
	// 上报变更信息
	s.AddAuditLog(signmodel.SignUpLogBizID, signmodel.SignUpMidUpdate, "修改", int64(arg.AdminID), arg.AdminName, []int64{int64(arg.Mid)}, index, content)
	return
}

// ViolationAdd .
func (s *Service) ViolationAdd(context context.Context, arg *signmodel.ViolationArg) (result signmodel.CommonResponse, err error) {
	if arg == nil || arg.SignID == 0 {
		log.Error("violation add arg is nil")
		return
	}
	su := &signmodel.SignUp{}
	if err = s.crmdb.GetDb().Table(signmodel.TableSignUp).Where("id = ? AND state = 0", arg.SignID).Find(su).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("db fail, err=%+v", err)
		return
	}
	if err == gorm.ErrRecordNotFound {
		err = fmt.Errorf("签约ID(%d)不存在", arg.SignID)
		return
	}
	var bmContext, ok = context.(*blademaster.Context)
	if ok {
		uid, ok := util.GetContextValueInt64(bmContext, "uid")
		if ok {
			arg.AdminID = uid
		}
		name, ok := util.GetContextValueString(bmContext, "username")
		if ok {
			arg.AdminName = name
		}
	}
	log.Info("add sign up, req=%+v, admin id=%d, admin name=%s", arg, arg.AdminID, arg.AdminName)
	tx := s.crmdb.BeginTran(context)
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	// 新增违约历史
	vh := &signmodel.SignViolationHistory{}
	arg.CopyTo(vh)
	if err = tx.Save(vh).Error; err != nil {
		log.Error("sign violation up fail, err=%+v", err)
		return
	}
	// 新增违约次数
	if err = tx.Table(signmodel.TableSignUp).Where("id = ?", arg.SignID).UpdateColumns(
		map[string]interface{}{
			"violation_times": gorm.Expr("violation_times + ?", 1),
			"admin_id":        arg.AdminID,
			"admin_name":      arg.AdminName,
		}).Error; err != nil {
		log.Error("sign up add violation times fail, err=%+v", err)
	}
	return
}

// ViolationRetract .
func (s *Service) ViolationRetract(context context.Context, arg *signmodel.IDArg) (result signmodel.CommonResponse, err error) {
	var bmContext, ok = context.(*blademaster.Context)
	if ok {
		uid, ok := util.GetContextValueInt64(bmContext, "uid")
		if ok {
			arg.AdminID = uid
		}
		name, ok := util.GetContextValueString(bmContext, "username")
		if ok {
			arg.AdminName = name
		}
	}
	log.Info("add sign up, req=%+v, admin id=%d, admin name=%s", arg, arg.AdminID, arg.AdminName)
	tx := s.crmdb.BeginTran(context)
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	// 删除违约历史
	if err = tx.Table(signmodel.TableSignViolationHistory).Where("id = ?", arg.ID).UpdateColumns(
		map[string]interface{}{
			"state":      100,
			"admin_id":   arg.AdminID,
			"admin_name": arg.AdminName,
		}).Error; err != nil {
		log.Error("sign violation Retract  fail, err=%+v", err)
	}
	// 减少违约次数
	if err = tx.Table(signmodel.TableSignUp).Where("id = ?", arg.SignID).UpdateColumns(
		map[string]interface{}{
			"violation_times": gorm.Expr("violation_times - ?", 1),
			"admin_id":        arg.AdminID,
			"admin_name":      arg.AdminName,
		}).Error; err != nil {
		log.Error("sign up dec violation times fail, err=%+v", err)
	}
	return
}

// ViolationList .
func (s *Service) ViolationList(context context.Context, arg *signmodel.PageArg) (result *signmodel.ViolationResult, err error) {
	if arg == nil {
		log.Error("arg is nil")
		return
	}
	if arg.Page <= 0 {
		arg.Page = 1
	}
	if arg.Size <= 0 || arg.Size >= 50 {
		arg.Size = 20
	}
	result = new(signmodel.ViolationResult)
	result.Result = []*signmodel.ViolationArg{}
	result.Page = arg.Page
	result.Size = arg.Size
	var (
		count  int
		offset = (arg.Page - 1) * arg.Size
		vhs    = []*signmodel.SignViolationHistory{}
	)
	if err = s.crmdb.GetDb().Table(signmodel.TableSignViolationHistory).Where("sign_id = ?", arg.SignID).Count(&count).Error; err != nil {
		log.Error("violation count fail, err=%+v", err)
		return
	}
	if count <= 0 {
		return
	}
	result.TotalCount = count
	if err = s.crmdb.GetDb().Table(signmodel.TableSignViolationHistory).Where("sign_id = ?", arg.SignID).Order(fmt.Sprintf("%s %s", "mtime", "DESC")).
		Offset(offset).
		Limit(arg.Size).
		Find(&vhs).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("violationList fail, err=%+v", err)
	}
	for _, v := range vhs {
		var re = &signmodel.ViolationArg{}
		re.CopyFrom(v)
		result.Result = append(result.Result, re)
	}
	return
}

// AbsenceAdd .
func (s *Service) AbsenceAdd(context context.Context, arg *signmodel.AbsenceArg) (result signmodel.CommonResponse, err error) {
	if arg == nil || arg.SignID == 0 {
		log.Error("violation add arg is nil")
		return
	}
	su := &signmodel.SignUp{}
	if err = s.crmdb.GetDb().Table(signmodel.TableSignUp).Where("id = ? AND state = 0", arg.SignID).Find(su).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("db fail, err=%+v", err)
		return
	}
	if err == gorm.ErrRecordNotFound {
		err = fmt.Errorf("签约ID(%d)不存在", arg.SignID)
		return
	}
	var Result struct {
		LeaveTimes int
	}
	if err = s.crmdb.GetDb().Table(signmodel.TableSignTaskAbsence).Select("SUM(absence_count) as leave_times").Where("sign_id = ? AND state = 0", arg.SignID).Scan(&Result).Error; err != nil {
		log.Error("sign task absence sum fail, err=%+v", err)
		return
	}
	var bmContext, ok = context.(*blademaster.Context)
	if ok {
		uid, ok := util.GetContextValueInt64(bmContext, "uid")
		if ok {
			arg.AdminID = uid
		}
		name, ok := util.GetContextValueString(bmContext, "username")
		if ok {
			arg.AdminName = name
		}
	}
	log.Info("add sign up, req=%+v, admin id=%d, admin name=%s", arg, arg.AdminID, arg.AdminName)
	tx := s.crmdb.BeginTran(context)
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	var sth *signmodel.SignTaskHistory
	// 查询签约周期任务历史数据，没有新增
	if sth, err = s.getOrCreateTaskHistory(tx, arg.SignID); err != nil {
		log.Error("s.getOrCreateTaskHistory(%d), err=%+v", arg.SignID, err)
		return
	}
	// 增加请假历史
	ta := &signmodel.SignTaskAbsence{}
	arg.CopyTo(ta)
	ta.TaskHistoryID = sth.ID
	if err = tx.Save(ta).Error; err != nil {
		log.Error("sign task absence  fail, err=%+v", err)
		return
	}
	// 新增请假历史
	if err = tx.Table(signmodel.TableSignUp).Where("id = ?", arg.SignID).UpdateColumns(
		map[string]interface{}{
			"leave_times": Result.LeaveTimes + arg.AbsenceCount,
			"admin_id":    arg.AdminID,
			"admin_name":  arg.AdminName,
		}).Error; err != nil {
		log.Error("sign up add leave time fail, err=%+v", err)
	}
	return
}

// get task history, if not exist, then will create it
func (s *Service) getOrCreateTaskHistory(tx *gorm.DB, signID int64) (res *signmodel.SignTaskHistory, err error) {
	st := new(signmodel.SignTask)
	if err = s.crmdb.GetDb().Select("*").Where("sign_id = ?", signID).Find(&st).Error; err != nil {
		return
	}
	if res, _, err = s.crmdb.GetOrCreateTaskHistory(tx, st); err != nil {
		log.Error("s.crmdb.GetOrCreateTaskHistory, err=%+v", err)
	}
	return
}

// AbsenceRetract .
func (s *Service) AbsenceRetract(context context.Context, arg *signmodel.IDArg) (result signmodel.CommonResponse, err error) {
	var bmContext, ok = context.(*blademaster.Context)
	if ok {
		uid, ok := util.GetContextValueInt64(bmContext, "uid")
		if ok {
			arg.AdminID = uid
		}
		name, ok := util.GetContextValueString(bmContext, "username")
		if ok {
			arg.AdminName = name
		}
	}
	log.Info("add sign up, req=%+v, admin id=%d, admin name=%s", arg, arg.AdminID, arg.AdminName)
	tx := s.crmdb.BeginTran(context)
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	signTaskAbsences := &signmodel.SignTaskAbsence{}
	if err = s.crmdb.GetDb().Table(signmodel.TableSignTaskAbsence).Select("absence_count").Where("id = ? AND state = 0", arg.ID).Find(&signTaskAbsences).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("sign task absence_count fail, err=%+v", err)
		return
	}
	if err == gorm.ErrRecordNotFound {
		err = fmt.Errorf("签约ID(%d)的请假ID(%d)不存在", arg.SignID, arg.ID)
		return
	}
	// 删除请假历史
	if err = tx.Table(signmodel.TableSignTaskAbsence).Where("id = ?", arg.ID).UpdateColumns(
		map[string]interface{}{
			"state":      100,
			"admin_id":   arg.AdminID,
			"admin_name": arg.AdminName,
		}).Error; err != nil {
		log.Error("task absence Retract  fail, err=%+v", err)
	}
	// 减少请假次数
	if err = tx.Table(signmodel.TableSignUp).Where("id = ?", arg.SignID).UpdateColumns(
		map[string]interface{}{
			"leave_times": gorm.Expr("leave_times - ?", signTaskAbsences.AbsenceCount),
			"admin_id":    arg.AdminID,
			"admin_name":  arg.AdminName,
		}).Error; err != nil {
		log.Error("sign up dec leave times fail, err=%+v", err)
	}
	return
}

// AbsenceList .
func (s *Service) AbsenceList(context context.Context, arg *signmodel.PageArg) (result *signmodel.AbsenceResult, err error) {
	if arg == nil {
		log.Error("arg is nil")
		return
	}
	if arg.Page <= 0 {
		arg.Page = 1
	}
	if arg.Size <= 0 || arg.Size >= 50 {
		arg.Size = 20
	}
	result = new(signmodel.AbsenceResult)
	result.Result = []*signmodel.AbsenceArg{}
	result.Page = arg.Page
	result.Size = arg.Size
	var (
		count      int
		taskHisIDs []int64
		mst        = make(map[int64]*signmodel.SignTaskHistory)
		offset     = (arg.Page - 1) * arg.Size
		tas        = []*signmodel.SignTaskAbsence{}
		sts        = []*signmodel.SignTaskHistory{}
		su         = &signmodel.SignUp{}
	)
	if err = s.crmdb.GetDb().Table(signmodel.TableSignUp).Where("id = ? AND state IN (0,1)", arg.SignID).Find(su).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("db fail, err=%+v", err)
		return
	}
	if err == gorm.ErrRecordNotFound {
		err = fmt.Errorf("up签约不存在")
		return
	}
	if err = s.crmdb.GetDb().Table(signmodel.TableSignTaskAbsence).Where("sign_id = ?", arg.SignID).Count(&count).Error; err != nil {
		log.Error("sign task absence count fail, err=%+v", err)
		return
	}
	if count <= 0 {
		return
	}
	result.TotalCount = count
	if err = s.crmdb.GetDb().Table(signmodel.TableSignTaskAbsence).Where("sign_id = ?", arg.SignID).Order(fmt.Sprintf("%s %s", "mtime", "DESC")).
		Offset(offset).
		Limit(arg.Size).
		Find(&tas).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("absenceList fail, err=%+v", err)
	}
	for _, v := range tas {
		taskHisIDs = append(taskHisIDs, v.TaskHistoryID)
	}
	if err = s.crmdb.GetDb().Table(signmodel.TableSignTaskHistory).Where("id IN (?) AND sign_id = ?", taskHisIDs, arg.SignID).Find(&sts).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("sign task history fail, err=%+v", err)
		return
	}
	for _, v := range sts {
		mst[v.ID] = v
	}
	for _, v := range tas {
		var (
			ok           bool
			sDate, eDate time.Time
			st           *signmodel.SignTaskHistory
			re           = &signmodel.AbsenceArg{}
		)
		// 从任务历史里面获取签约周期
		if st, ok = mst[int64(v.TaskHistoryID)]; ok {
			if st.TaskType != signmodel.TaskTypeAccumulate {
				sDate, eDate = signmodel.GetTaskDuration(st.GenerateDate.Time(), st.TaskType)
				re.TaskBegin = xtime.Time(sDate.Unix())
				re.TaskEnd = xtime.Time(eDate.Unix())
			} else {
				re.TaskBegin = su.BeginDate
				re.TaskEnd = su.EndDate
			}
		}
		re.CopyFrom(v)
		result.Result = append(result.Result, re)
	}
	return
}

// ViewCheck .
func (s *Service) ViewCheck(context context.Context, arg *signmodel.PowerCheckArg) (res *signmodel.PowerCheckReply, err error) {
	res = &signmodel.PowerCheckReply{}
	if arg == nil || arg.Mid == 0 {
		log.Error("view arg is nil")
		return
	}
	var count int64
	if err = s.crmdb.GetDb().Table(signmodel.TableSignUp).Where("mid = ?", arg.Mid).Count(&count).Error; err != nil {
		log.Error("db fail, err=%+v", err)
		return
	}
	if count > 0 {
		res.IsSign = true
	}
	var baseInfo upcrmmodel.UpBaseInfo
	if baseInfo, err = s.crmdb.QueryUpBaseInfo(arg.Mid, "active_tid"); err != nil && err != gorm.ErrRecordNotFound {
		log.Error("s.crmdb.QueryUpBaseInfo(%d), err=%+v", arg.Mid, err)
		return
	}
	if err == gorm.ErrRecordNotFound {
		err = nil
		return
	}
	for _, tid := range arg.TIDs {
		if tid == int16(baseInfo.ActiveTid) {
			res.IsPower = true
			return
		}
	}
	return
}

/*
	id, 最后插入的id
*/
func (s *Service) addPayInfo(tx *gorm.DB, arg *signmodel.SignPayInfoArg) (id int64, err error) {
	if arg == nil {
		err = errors.New("add pay info nil pointer")
		return
	}

	var dbInfo signmodel.SignPay
	arg.CopyTo(&dbInfo)
	var _, e = s.crmdb.InsertPayInfo(tx, &dbInfo)
	err = e
	id = dbInfo.ID
	return
}

func (s *Service) addTaskInfo(tx *gorm.DB, arg *signmodel.SignTaskInfoArg) (id int64, err error) {
	if arg == nil {
		err = errors.New("add task info nil pointer")
		return
	}

	var dbInfo signmodel.SignTask
	arg.CopyTo(&dbInfo)
	if _, err = s.crmdb.InsertTaskInfo(tx, &dbInfo); err != nil {
		log.Error("s.crmdb.InsertTaskInfo(%+v) error(%+v)", &dbInfo, err)
		return
	}
	id = dbInfo.ID
	if _, _, err = s.crmdb.GetOrCreateTaskHistory(tx, &dbInfo); err != nil {
		log.Error("s.crmdb.GetOrCreateTaskHistory(%+v) error(%+v)", &dbInfo, err)
	}
	return
}

func (s *Service) addContractInfo(tx *gorm.DB, arg *signmodel.SignContractInfoArg) (id int64, err error) {
	if arg == nil {
		err = errors.New("add contract info nil pointer")
		return
	}

	var dbInfo signmodel.SignContract
	arg.CopyTo(&dbInfo)
	var _, e = s.crmdb.InsertContractInfo(tx, &dbInfo)
	err = e
	id = dbInfo.ID
	return
}

// type sortPayFunc func(p1, p2 *signmodel.SignPayInfoArg) bool

// type paySorter struct {
// 	datas []*signmodel.SignPayInfoArg
// 	by    sortPayFunc // Closure used in the Less method.
// }

// Len is part of sort.Interface.
// func (s *paySorter) Len() int {
// 	return len(s.datas)
// }

// // Swap is part of sort.Interface.
// func (s *paySorter) Swap(i, j int) {
// 	s.datas[i], s.datas[j] = s.datas[j], s.datas[i]
// }

// // Less is part of sort.Interface. It is implemented by calling the "by" closure in the sorter.
// func (s *paySorter) Less(i, j int) bool {
// 	return s.by(s.datas[i], s.datas[j])
// }

// func sortPayInfo(planets []*signmodel.SignPayInfoArg, sortfunc sortPayFunc) {
// 	ps := &paySorter{
// 		datas: planets,
// 		by:    sortfunc, // The Sort method's receiver is the function (closure) that defines the sort order.
// 	}
// 	sort.Sort(ps)
// }

// func sortByDueAsc(p1, p2 *signmodel.SignPayInfoArg) bool {
// 	var v1, _ = time.Parse(upcrmmodel.TimeFmtDate, p1.DueDate)
// 	var v2, _ = time.Parse(upcrmmodel.TimeFmtDate, p2.DueDate)
// 	return v1.Before(v2)
// }

//SignQuery sign query
func (s *Service) SignQuery(c context.Context, arg *signmodel.SignQueryArg) (res *signmodel.SignQueryResult, err error) {
	if arg == nil {
		log.Error("arg is nil")
		return
	}
	if arg.Page <= 0 {
		arg.Page = 1
	}
	if arg.IsDetail == signmodel.SignUpDetail {
		arg.Size = 5
	} else {
		if arg.Size <= 0 || arg.Size > 20 {
			arg.Size = 20
		}
	}
	var (
		count                 int
		mids                  []int64
		tids                  []int64
		signIDs               []int64
		signTaskIDs           []int64
		signTaskHistoryIDs    []int64
		tpNames               map[int64]string
		db                    = s.crmdb.GetDb()
		signUpHandle          = db.Table(signmodel.TableSignUp)
		signPayHandle         = db.Table(signmodel.TableSignPay)
		signContractHandle    = db.Table(signmodel.TableSignContract)
		signTaskHistoryHandle = db.Table(signmodel.TableSignTaskHistory)
		signAbsenceHandle     = db.Table(signmodel.TableSignTaskAbsence)
		signTaskHandle        = db.Table(signmodel.TableSignTask)
		signUps               = []*signmodel.SignUp{}
		signPayInfos          = []*signmodel.SignPay{}
		signContractInfos     = []*signmodel.SignContract{}
		signTaskHistorys      = []*signmodel.SignTaskHistory{}
		signTaskAbsences      = []*signmodel.SignTaskAbsence{}
		signTasks             = []*signmodel.SignTask{}
		signUpBaseInfos       = []*signmodel.SignUpBaseInfo{}
		signPayInfoMap        = make(map[int64][]*signmodel.SignPayInfoArg)
		signContractInfoMap   = make(map[int64][]*signmodel.SignContractInfoArg)
		signTaskHistoryMap    = make(map[int64][]*signmodel.SignTaskHistoryArg)
		offset                = (arg.Page - 1) * arg.Size
	)
	res = new(signmodel.SignQueryResult)
	res.Page = arg.Page
	res.Size = arg.Size
	res.Result = []*signmodel.SignUpsArg{}
	if len(arg.Tids) != 0 {
		signUpHandle = signUpHandle.Where("active_tid IN (?)", arg.Tids)
	}
	if arg.Mid != 0 {
		signUpHandle = signUpHandle.Where("mid = ?", arg.Mid)
	}
	if arg.DueSign != 0 {
		signUpHandle = signUpHandle.Where("due_warn = ?", 2)
	}
	if arg.DuePay != 0 {
		signUpHandle = signUpHandle.Where("pay_expire_state = ?", 2)
	}
	if arg.ExpireSign != 0 {
		signUpHandle = signUpHandle.Where("state = ?", 1)
	}
	if arg.Sex != -1 {
		signUpHandle = signUpHandle.Where("sex = ?", arg.Sex)
	}
	if len(arg.Country) != 0 {
		signUpHandle = signUpHandle.Where("country IN (?)", arg.Country)
	}
	if arg.ActiveTID != 0 {
		signUpHandle = signUpHandle.Where("active_tid = ?", arg.ActiveTID)
	}
	if arg.SignType != 0 {
		signUpHandle = signUpHandle.Where("sign_type = ?", arg.SignType)
	}
	if arg.TaskState != 0 {
		signUpHandle = signUpHandle.Where("task_state = ?", arg.TaskState)
	}
	if arg.SignBegin != 0 {
		signUpHandle = signUpHandle.Where("begin_date >= ?", arg.SignBegin)
	}
	if arg.SignEnd != 0 {
		signUpHandle = signUpHandle.Where("end_date <= ?", arg.SignEnd)
	}
	signUpHandle = signUpHandle.Where("state IN (0,1)")
	if err = signUpHandle.Count(&count).Error; err != nil {
		log.Error("signUps count fail, err=%+v", err)
		return
	}
	if count <= 0 {
		return
	}
	res.TotalCount = count
	if arg.IsDetail == signmodel.SignUpDetail {
		signUpHandle = signUpHandle.Order(fmt.Sprintf("%s %s", "id", "DESC"))
	} else {
		signUpHandle = signUpHandle.Order(fmt.Sprintf("%s %s", "mtime", "DESC"))
	}
	if err = signUpHandle.Offset(offset).Limit(arg.Size).Find(&signUps).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("signUps fail, err=%+v", err)
		return
	}
	for _, v := range signUps {
		var signUpBaseInfo = &signmodel.SignUpBaseInfo{}
		signUpBaseInfo.CopyFrom(v)
		signUpBaseInfos = append(signUpBaseInfos, signUpBaseInfo)
		signIDs = append(signIDs, v.ID)
		mids = append(mids, v.Mid)
		tids = append(tids, int64(v.ActiveTid))
	}
	tpNames = cache.GetTidName(tids...)
	var infosReply *accgrpc.InfosReply
	if infosReply, err = global.GetAccClient().Infos3(c, &accgrpc.MidsReq{Mids: mids, RealIp: metadata.String(c, metadata.RemoteIP)}); err != nil {
		log.Error("global.GetAccClient().Infos3(%+v)  error(%+v)", mids, err)
		err = nil
	}
	if err = signPayHandle.Where("sign_id IN (?) AND state IN (0,1)", signIDs).Order(fmt.Sprintf("%s %s", "due_date", "ASC")).Find(&signPayInfos).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("sign pays fail, err=%+v", err)
		return
	}
	for _, v := range signPayInfos {
		var signPayInfo = &signmodel.SignPayInfoArg{}
		signPayInfo.CopyFrom(v)
		signPayInfoMap[v.SignID] = append(signPayInfoMap[v.SignID], signPayInfo)
	}
	if err = signContractHandle.Where("sign_id IN (?) AND state = 0", signIDs).Order(fmt.Sprintf("%s %s", "id", "ASC")).Find(&signContractInfos).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("sign contract fail, err=%+v", err)
		return
	}
	for _, v := range signContractInfos {
		var signContractInfo = &signmodel.SignContractInfoArg{}
		signContractInfo.CopyFrom(v)
		signContractInfoMap[v.SignID] = append(signContractInfoMap[v.SignID], signContractInfo)
	}
	// task
	if err = signTaskHandle.Where("sign_id IN (?) AND state = 0", signIDs).Find(&signTasks).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("sign task fail, err=%+v", err)
		return
	}
	for _, v := range signTasks {
		signTaskIDs = append(signTaskIDs, v.ID)
	}
	// task history  NOTE: mtime 解决generate_date为累积时没用办法排序 有一定风险会错乱
	if arg.IsDetail == signmodel.SignUpList {
		var signTaskHistorySQL = `SELECT * FROM sign_task_history WHERE task_template_id IN (?) AND state IN (1,2) AND mtime = (SELECT MAX(mtime) FROM sign_task_history s 
		WHERE s.sign_id=sign_task_history.sign_id AND s.task_template_id IN (?) AND s.state IN (1,2))`
		if err = signTaskHistoryHandle.Raw(signTaskHistorySQL, signTaskIDs, signTaskIDs).Find(&signTaskHistorys).Error; err != nil && err != gorm.ErrRecordNotFound {
			log.Error("sign task history fail, err=%+v", err)
			return
		}
	} else {
		if err = signTaskHistoryHandle.Where("task_template_id IN (?) AND state IN (1,2)", signTaskIDs).Order(fmt.Sprintf("%s %s", "id", "DESC")).Find(&signTaskHistorys).Error; err != nil && err != gorm.ErrRecordNotFound {
			log.Error("sign task history fail, err=%+v", err)
			return
		}
	}
	for _, v := range signTaskHistorys {
		signTaskHistoryIDs = append(signTaskHistoryIDs, v.ID)
	}
	if err = signAbsenceHandle.Raw("select sum(absence_count)as absence_count, task_history_id from sign_task_absence where task_history_id IN (?) AND state = 0 group by task_history_id", signTaskHistoryIDs).Find(&signTaskAbsences).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("sign absence fail, err=%+v", err)
		return
	}
	var hidMap = make(map[int64]int)
	for _, v := range signTaskAbsences {
		hidMap[v.TaskHistoryID] = v.AbsenceCount
	}
	for _, v := range signTaskHistorys {
		var (
			absenceCounter     int
			signTaskHistoryArg = &signmodel.SignTaskHistoryArg{}
		)
		if count, ok := hidMap[v.ID]; ok {
			absenceCounter = count
		}
		signTaskHistoryArg.CopyFrom(v, absenceCounter)
		signTaskHistoryMap[v.SignID] = append(signTaskHistoryMap[v.SignID], signTaskHistoryArg)
	}
	for _, v := range signUpBaseInfos {
		if tpName, ok := tpNames[int64(v.ActiveTid)]; ok {
			v.TypeName = tpName
		}
		if infosReply != nil && infosReply.Infos != nil {
			if info, ok := infosReply.Infos[v.Mid]; ok {
				v.Name = info.Name
			}
		}
		if arg.IsDetail == signmodel.SignUpDetail {
			res.SignBaseInfo = v
		}
		var signUpsArg = &signmodel.SignUpsArg{}
		signUpsArg.SignUpBaseInfo = *v
		if signPayInfoArg, ok := signPayInfoMap[v.ID]; ok {
			signUpsArg.PayInfo = signPayInfoArg
		}
		if signContractInfoArg, ok := signContractInfoMap[v.ID]; ok {
			signUpsArg.ContractInfo = signContractInfoArg
		}
		if signTaskHistoryArg, ok := signTaskHistoryMap[v.ID]; ok {
			for _, sth := range signTaskHistoryArg {
				if sth.TaskType == signmodel.TaskTypeAccumulate {
					sth.TaskBegin = v.BeginDate
					sth.TaskEnd = v.EndDate
				}
			}
			signUpsArg.TaskHistoryInfo = signTaskHistoryArg
		}
		res.Result = append(res.Result, signUpsArg)
	}
	return
}

// SignQueryID .
func (s *Service) SignQueryID(c context.Context, arg *signmodel.SignIDArg) (res *signmodel.SignUpArg, err error) {
	var (
		tpNames         map[int64]string
		signUp          *signmodel.SignUp
		signPayMap      map[int64]*signmodel.SignPay
		signTaskMap     map[int64]*signmodel.SignTask
		signContractMap map[int64]*signmodel.SignContract
	)
	res = new(signmodel.SignUpArg)
	if signUp, signPayMap, signTaskMap, signContractMap, err = s.crmdb.SignUpID(arg.ID); err != nil {
		log.Error("s.crmdb.SignUpID(%+d) error(%+v)", arg.ID, err)
		return
	}
	if signUp == nil {
		return
	}
	var infoReply *accgrpc.InfoReply
	if infoReply, err = global.GetAccClient().Info3(c, &accgrpc.MidReq{Mid: signUp.Mid, RealIp: metadata.String(c, metadata.RemoteIP)}); err != nil {
		log.Error("global.GetAccClient().Infos3(%d)  error(%+v)", signUp.Mid, err)
		err = nil
	}
	tpNames = cache.GetTidName(int64(signUp.ActiveTid))
	res.SignUpBaseInfo.CopyFrom(signUp)
	if infoReply != nil && infoReply.Info != nil {
		res.SignUpBaseInfo.Name = infoReply.Info.Name
	}
	if tpName, ok := tpNames[int64(signUp.ActiveTid)]; ok {
		res.SignUpBaseInfo.TypeName = tpName
	}
	for _, v := range signPayMap {
		var payInfo = &signmodel.SignPayInfoArg{}
		payInfo.CopyFrom(v)
		res.PayInfo = append(res.PayInfo, payInfo)
	}
	if signPayMap != nil {
		sort.Slice(res.PayInfo, func(i int, j int) bool {
			return res.PayInfo[i].DueDate < res.PayInfo[j].DueDate
		})
	}
	for _, v := range signTaskMap {
		var taskInfo = &signmodel.SignTaskInfoArg{}
		taskInfo.CopyFrom(v)
		res.TaskInfo = append(res.TaskInfo, taskInfo)
	}
	if signTaskMap != nil {
		sort.Slice(res.TaskInfo, func(i int, j int) bool {
			return res.TaskInfo[i].ID < res.TaskInfo[j].ID
		})
	}
	for _, v := range signContractMap {
		var contractInfo = &signmodel.SignContractInfoArg{}
		contractInfo.CopyFrom(v)
		res.ContractInfo = append(res.ContractInfo, contractInfo)
	}
	if signContractMap != nil {
		sort.Slice(res.ContractInfo, func(i int, j int) bool {
			return res.ContractInfo[i].ID < res.ContractInfo[j].ID
		})
	}
	return
}

// SignPayComplete complete sign pay
func (s *Service) SignPayComplete(con context.Context, arg *signmodel.SignPayCompleteArg) (result signmodel.SignPayCompleteResult, err error) {
	var affectedrow, e = s.crmdb.PayComplete(arg.IDs)
	if e != nil {
		err = e
		log.Error("fail to complete pay task, err=%+v", e)
		return
	}
	log.Info("complete pay, id=%+v, affected row=%d", arg.IDs, affectedrow)
	return
}

// SignCheckExist check sign up has an valid contract
func (s *Service) SignCheckExist(c context.Context, arg *signmodel.SignCheckExsitArg) (result signmodel.SignCheckExsitResult, err error) {
	result.Exist, err = s.crmdb.CheckUpHasValidContract(arg.Mid, time.Now())
	if err != nil {
		log.Error("check up has valid contract fail, err=%+v", err)
	}
	return
}

// Countrys .
func (s *Service) Countrys(c context.Context, arg *signmodel.CommonArg) (res *signmodel.SignCountrysReply, err error) {
	var (
		signUp       []*signmodel.SignUp
		db           = s.crmdb.GetDb()
		signUpHandle = db.Table(signmodel.TableSignUp)
	)
	res = new(signmodel.SignCountrysReply)
	if err = signUpHandle.Raw("select DISTINCT(country) from sign_up").Find(&signUp).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("sign up fail, err=%+v", err)
	}
	if err == gorm.ErrRecordNotFound {
		err = nil
		return
	}
	for _, v := range signUp {
		if v.Country == "" {
			continue
		}
		res.List = append(res.List, v.Country)
	}
	return
}

// Tids .
func (s *Service) Tids(c context.Context, arg *signmodel.CommonArg) (res *signmodel.SignTidsReply, err error) {
	var (
		tids         []int64
		signUp       []*signmodel.SignUp
		db           = s.crmdb.GetDb()
		signUpHandle = db.Table(signmodel.TableSignUp)
	)
	res = new(signmodel.SignTidsReply)
	if err = signUpHandle.Raw("select DISTINCT(active_tid) from sign_up").Find(&signUp).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("sign up fail, err=%+v", err)
	}
	if err == gorm.ErrRecordNotFound {
		err = nil
		return
	}
	for _, v := range signUp {
		if v.ActiveTid == 0 {
			continue
		}
		tids = append(tids, int64(v.ActiveTid))
	}
	res.List = cache.GetTidName(tids...)
	return
}