package logic

import (
	"errors"
	"fmt"
	"git.rtzhtech.cn/iss/public-lib/dao"
	"git.rtzhtech.cn/iss/public-lib/dto"
	"git.rtzhtech.cn/iss/public-lib/model"
	"git.rtzhtech.cn/iss/public-lib/svc"
	"github.com/gogf/gf/v2/util/gconv"
	"gorm.io/gen/field"
)

type LinkStrategyLogic struct {
	SvcCtx *svc.ServiceContext
}

// NewLinkStrategyLogic
// @Description: 联动策略
// @return *LinkStrategyLogic
func NewLinkStrategyLogic() *LinkStrategyLogic {
	return &LinkStrategyLogic{
		SvcCtx: svc.SvcCtx,
	}
}

// AddLinkStrategy
// @Description: 添加
// @receiver l
// @param in
// @return error
func (l *LinkStrategyLogic) AddLinkStrategy(in *dto.AddLinkStrategyRes) error {
	in.LinkStrategy.ID = 0
	err := l.SvcCtx.LinkStrategy.Create(&in.LinkStrategy)
	if err != nil {
		return err
	}

	return l.addRelation(in)
}

// addRelation
// @Description: 添加关联表
// @receiver l
// @param in
// @return error
func (l *LinkStrategyLogic) addRelation(in *dto.AddLinkStrategyRes) error {
	for i := 0; i < len(in.Src); i++ {
		in.Src[i].ID = 0
		in.Src[i].Strategyid = in.Strategyid
	}
	err := l.SvcCtx.LinkRelationObj.CreateInBatches(in.Src, len(in.Src))
	if err != nil {
		return err
	}
	for i := 0; i < len(in.Dst); i++ {
		in.Dst[i].ID = 0
		in.Dst[i].Strategyid = in.Strategyid
	}
	err = l.SvcCtx.LinkRelationAction.CreateInBatches(in.Dst, len(in.Dst))
	return err
}

// DelLinkStrategy
// @Description: 删除
// @receiver l
// @param id
// @return error
func (l *LinkStrategyLogic) DelLinkStrategy(strategyId int64) error {
	do := l.SvcCtx.LinkStrategy
	_, err := do.Where(do.Strategyid.Eq(strategyId)).Delete()
	if err != nil {
		return err
	}

	return l.delRelation(strategyId)
}

// delRelation
// @Description: 删除关联表
// @receiver l
// @param strategyId
// @return error
func (l *LinkStrategyLogic) delRelation(strategyId int64) error {
	_, err := l.SvcCtx.LinkRelationObj.Where(l.SvcCtx.LinkRelationObj.Strategyid.Eq(strategyId)).Delete()
	if err != nil {
		return err
	}
	_, err = l.SvcCtx.LinkRelationAction.Where(l.SvcCtx.LinkRelationAction.Strategyid.Eq(strategyId)).Delete()
	return err
}

// ModifyLinkStrategy
// @Description: 修改
// @receiver l
// @param in 可修改除策略ID和APP id外的信息
// @param fields 更新linkStrategy字段，当field为null时，更新in的全部字段
// @return error
func (l *LinkStrategyLogic) ModifyLinkStrategy(in *dto.AddLinkStrategyRes, fields ...string) error {
	do := l.SvcCtx.LinkStrategy
	_do := do.Omit(do.ID, do.Strategyid, do.Appid).Where(do.Strategyid.Eq(in.Strategyid))

	c, err := _do.Count()
	if c < 1 {
		return errors.New(fmt.Sprintf("not find,strategyId:%v", in.Strategyid))
	}
	if fields == nil {
		m := gconv.Map(in.LinkStrategy)
		_, err = _do.Updates(m)
	} else {
		var fieldList []field.Expr
		for _, v := range fields {
			_f, ok := do.GetFieldByName(v)
			if ok {
				fieldList = append(fieldList, _f)
			}
		}
		_, err = _do.Select(fieldList...).Updates(in.LinkStrategy)
	}
	if err != nil {
		return err
	}

	err = l.delRelation(in.Strategyid)
	if err != nil {
		return err
	}
	err = l.addRelation(in)
	return err
}

func (l *LinkStrategyLogic) getLinkStrategyCond(req *dto.GetLinkStrategyReq) *dao.Condition {
	strategy := l.SvcCtx.LinkStrategy
	cond := NewCondition(&req.LimitPage)

	if req.StrategyId > 0 {
		cond.Where[strategy.Strategyid.String()] = req.StrategyId
	}
	if req.AppId > 0 {
		cond.Where[strategy.Appid.String()] = req.AppId
	}
	if req.StrategyName != "" {
		cond.Where[strategy.Strategyname.String()+" like ?"] = "%" + req.StrategyName + "%"
	}
	return cond
}

// GetLinkStrategy
// @Description: 分页查询
// @receiver l
// @param where 查询条件
// @param page
// @param limit
// @return []*model.LinkStrategy
// @return error
func (l *LinkStrategyLogic) GetLinkStrategy(req *dto.GetLinkStrategyReq) (*dto.GetLinkStrategyResp, error) {
	ctx := l.SvcCtx
	strategy := l.SvcCtx.LinkStrategy
	var linkStrategyList []*model.LinkStrategy

	cond := l.getLinkStrategyCond(req)
	err := strategy.Base.Find(cond, &linkStrategyList)
	if err != nil {
		return nil, err
	}
	resp := &dto.GetLinkStrategyResp{}
	err = strategy.Base.Count(cond, &resp.Total)
	if err != nil {
		return nil, err
	}

	for _, v := range linkStrategyList {
		var o dto.LinkStrategyDto
		o.LinkStrategy = *v
		tmpFormList, err := ctx.LinkRelationObj.Where(ctx.LinkRelationObj.Strategyid.Eq(v.Strategyid)).Find()
		if err != nil {
			return nil, err
		}
		for _, v2 := range tmpFormList {
			src := &dto.LinkStrategySrc{}
			src.Value = v2.Value
			src.Than = v2.Than
			src.Relation = v2.Relation
			devMpinfo, err := ctx.DevMpinfo.Where(ctx.DevMpinfo.Mpid.Eq(v2.Linkfromid)).Last()
			if err != nil {
				return nil, err
			}
			src.DevMpinfo = *devMpinfo
			o.Src = append(o.Src, src)
		}

		tmpDst := map[int64]*dto.LinkStrategyDst{}
		tmpToList, err := ctx.LinkRelationAction.Where(ctx.LinkRelationAction.Strategyid.Eq(v.Strategyid)).Find()
		for _, v3 := range tmpToList {
			dst, ok := tmpDst[v3.Linktoid]
			if !ok {
				dst = &dto.LinkStrategyDst{}
				tmpDst[v3.Linktoid] = dst
				devCpinfo, err := ctx.DevCpinfo.Where(ctx.DevCpinfo.Cpid.Eq(v3.Linktoid)).Last()
				if err != nil {
					return nil, err
				}
				dst.DevCpinfo = *devCpinfo
			}
			devCpaction, err := ctx.DevCpaction.Where(ctx.DevCpaction.Actid.Eq(v3.Actid)).Last()
			if err != nil {
				return nil, err
			}
			linkAction := dto.LinkAction{}
			linkAction.DevCpaction = *devCpaction
			linkAction.ActIndex = v3.Actindex
			linkAction.Delay = v3.Delay
			dst.Action = append(dst.Action, &linkAction)
		}
		for _, v4 := range tmpDst {
			o.Dst = append(o.Dst, v4)
		}

		resp.List = append(resp.List, &o)
	}
	return resp, err
}

// GetLinkStrategyCount
// @Description:查询满足条件的总数
// @receiver l
// @param where 查询条件
// @return int64
// @return error
func (l *LinkStrategyLogic) GetLinkStrategyCount(req *dto.GetLinkStrategyReq) (int64, error) {
	cond := l.getLinkStrategyCond(req)
	var count int64
	err := l.SvcCtx.LinkStrategy.Base.Count(cond, &count)
	if err != nil {
		return 0, err
	}
	return count, err
}