package containers

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

type ProjectList struct {
	logic.Logic

	Req *pb.ListReq
	Res *pb.ListRes
}

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

func (s *ProjectList) Exec() (err error) {
	if s.Req.GetShowUser() {
		return s.userList()
	}

	return s.adminList()
}

// 超级管理员能看到的数据
func (s *ProjectList) adminList() (err error) {
	m := s.GetDao().Project

	offset, limit := utils.PpDbLo(s.Req.GetPage(), s.Req.GetPerPage())
	list, total, err := m.WithContext(s.Ctx).Where(m.CompanyID.Eq(s.Req.GetCompanyId()), m.IsDel.Eq(mtype.No)).Order(m.ID.Desc()).FindByPage(offset, limit)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.Res.List = make([]*pb.ListRes_One, 0, len(list))
	s.Res.Total = total

	if total == 0 {
		return
	}

	var projectIds []int64
	for _, v := range list {
		projectIds = append(projectIds, v.ID)
	}

	projectUser, err := s._projectUser(projectIds)
	if err != nil {
		return
	}

	for _, v := range list {
		one := &pb.ListRes_One{
			Id:          v.ID,
			HashId:      v.HashID,
			Title:       v.Title,
			Domain:      v.Domain,
			CreatedTime: v.CreatedAt,
			UserRelate:  nil,
			Scene:       int32(v.Scene),
			LogoUrl:     v.LogoURL,
		}

		if relate, ok := projectUser[v.ID]; ok {
			one.UserRelate = make([]*pb.ListRes_UserRelate, 0, len(relate))
			for _, user := range relate {
				one.UserRelate = append(one.UserRelate, &pb.ListRes_UserRelate{
					UserId:   user.ID,
					HashId:   user.HashID,
					ShowName: user.ShowName,
				})
			}
		}

		s.Res.List = append(s.Res.List, one)
	}

	return
}

// 获取项目关联的员工
func (s *ProjectList) _projectUser(projectIds []int64) (map[int64][]*model.User, error) {
	relateM := s.GetDao().UserProjectRelate
	relate, err := relateM.WithContext(s.Ctx).Where(relateM.ProjectID.In(projectIds...), relateM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return nil, s.BE().MysqlError(err)
	}

	var urp = make(map[int64][]int64)

	var userIds []int64
	for _, v := range relate {
		if _, ok := urp[v.UserID]; !ok {
			userIds = append(userIds, v.UserID)
		}
		urp[v.UserID] = append(urp[v.UserID], v.ProjectID)
	}

	userM := s.GetDao().User
	user, err := userM.WithContext(s.Ctx).Select(userM.ID, userM.HashID, userM.ShowName).Where(userM.ID.In(userIds...), userM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return nil, s.BE().MysqlError(err)
	}

	var projectUser = make(map[int64][]*model.User)

	for _, v := range user {
		if pids, ok := urp[v.ID]; ok {
			for _, pid := range pids {
				projectUser[pid] = append(projectUser[pid], v)
			}
		}
	}

	return projectUser, nil
}

// 员工可见列表
func (s *ProjectList) userList() (err error) {
	relateM := s.GetDao().UserProjectRelate
	var projectIds []int64
	err = relateM.WithContext(s.Ctx).Where(relateM.UserID.Eq(s.Req.GetUserId()), relateM.IsDel.Eq(mtype.No)).Pluck(relateM.ProjectID, &projectIds)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	if len(projectIds) == 0 {
		return
	}

	m := s.GetDao().Project

	offset, limit := utils.PpDbLo(s.Req.GetPage(), s.Req.GetPerPage())
	list, total, err := m.WithContext(s.Ctx).Where(m.CompanyID.Eq(s.Req.GetCompanyId()), m.IsDel.Eq(mtype.No)).Order(m.ID.Desc()).FindByPage(offset, limit)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.Res.List = make([]*pb.ListRes_One, 0, len(list))
	s.Res.Total = total

	if total == 0 {
		return
	}

	user, err := finder.User(s.Ctx, s.Req.GetUserId())
	if err != nil {
		return
	}

	for _, v := range list {
		one := &pb.ListRes_One{
			Id:          v.ID,
			HashId:      v.HashID,
			Title:       v.Title,
			Domain:      v.Domain,
			CreatedTime: v.CreatedAt,
			UserRelate: []*pb.ListRes_UserRelate{
				{
					UserId:   user.ID,
					HashId:   user.HashID,
					ShowName: user.ShowName,
				},
			},
		}

		s.Res.List = append(s.Res.List, one)
	}
	return
}