package containers

import (
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_project"
	"joybuywork/proto/go_proto/workerr"

	"gorm.io/gen"
	"gorm.io/gen/field"
)

type ProjectUpdate struct {
	logic.Logic

	Req *pb.UpdateReq
	Res *pb.UpdateRes
}

func (s *ProjectUpdate) Run() (err error) {
	return logic.Run(s)
}

func (s *ProjectUpdate) Exec() (err error) {
	project, err := s.project()
	if err != nil {
		return
	}

	err = s.update(project)
	if err != nil {
		return
	}

	err = s.userRelate(project)
	if err != nil {
		return
	}

	return
}

// 找项目
func (s *ProjectUpdate) project() (project *model.Project, err error) {
	project, err = finder.Project(s.Ctx, s.Req.GetId(), s.Req.GetHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if project == nil || project.IsDel == mtype.Yes {
		return nil, workerr.NotFound("project not found")
	}

	return
}

// 更新项目信息
func (s *ProjectUpdate) update(project *model.Project) (err error) {
	m := s.GetDao().Project
	var updateField []field.AssignExpr
	isAll := utils.Ternary(s.Req.GetIsAll(), int8(mtype.Yes), int8(mtype.No))
	if project.Title != s.Req.GetTitle() || project.IsAll != isAll {
		updateField = append(updateField, m.Title.Value(s.Req.GetTitle()), m.IsAll.Value(isAll))
	}
	if project.LogoURL != s.Req.GetLogoUrl() {
		updateField = append(updateField, m.LogoURL.Value(s.Req.GetLogoUrl()))
	}

	//没有东西可以更新
	if len(updateField) == 0 {
		return
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(project.ID)).UpdateSimple(updateField...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewProject(s.Ctx).Clear(project)
	})

	return
}

func (s *ProjectUpdate) userRelate(project *model.Project) (err error) {
	// 更新项目关联关系
	if (project.IsAll == mtype.Yes) && s.Req.GetIsAll() { //如果之前是全员可看，现在也是，那证明不需要更新绑定关系
		return
	}

	//找到项目的关联员工
	relateM := s.GetDao().UserProjectRelate
	urp, err := relateM.WithContext(s.Ctx).Where(relateM.ProjectID.Eq(project.ID), relateM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	var urpMap = make(map[int64]*model.UserProjectRelate)
	for _, v := range urp {
		urpMap[v.UserID] = v
	}

	userM := s.GetDao().User
	var userCond = []gen.Condition{
		userM.IsDel.Eq(mtype.No),
	}
	var adds []*model.UserProjectRelate
	var dels []int64
	var newUserIds []int64
	if (project.IsAll == mtype.No) && s.Req.GetIsAll() { //如果以前不是全员可看，现在改成全员可看
		// 找到所有普通员工
		userCond = append(userCond, userM.CompanyID.Eq(project.CompanyID))
	} else {
		userCond = append(userCond, userM.HashID.In(s.Req.GetUserIds()...))
	}

	err = userM.WithContext(s.Ctx).Where(userCond...).Pluck(userM.ID, &newUserIds)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	var newUserMap = make(map[int64]struct{})

	// 新的员工id 不在旧的关系里面就要创建
	for _, v := range newUserIds {
		newUserMap[v] = struct{}{}
		if _, ok := urpMap[v]; !ok {
			adds = append(adds, withdefault.UserProjectRelate(&model.UserProjectRelate{
				UserID:    v,
				ProjectID: project.ID,
			}))
		}
	}

	// 旧的员工id 不在新的关系里面就要删除
	for _, v := range urp {
		if _, ok := newUserMap[v.UserID]; !ok {
			dels = append(dels, v.ID)
		}
	}

	if len(adds) > 0 {
		err = relateM.WithContext(s.Ctx).Create(adds...)
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(dels) > 0 {
		_, err = relateM.WithContext(s.Ctx).Where(relateM.ID.In(dels...)).UpdateSimple(relateM.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}