package service

import (
	"context"
	"fmt"
	"strconv"

	"git.nobla.cn/golang/aeus-admin/internal/logic"
	"git.nobla.cn/golang/aeus-admin/models"
	"git.nobla.cn/golang/aeus-admin/pb"
	"git.nobla.cn/golang/aeus/pkg/cache"
	"git.nobla.cn/golang/rest/types"
	"gorm.io/gorm"
)

type (
	departmentOptions struct {
		db    *gorm.DB
		cache cache.Cache
	}
	DepartmentOption func(o *departmentOptions)

	DepartmentService struct {
		opts  *departmentOptions
		logic *logic.Department
		user  *logic.User
	}
)

func WithDepartmentCache(cache cache.Cache) DepartmentOption {
	return func(o *departmentOptions) {
		o.cache = cache
	}
}

func WithDepartmentDB(db *gorm.DB) DepartmentOption {
	return func(o *departmentOptions) {
		o.db = db
	}
}

func (s *DepartmentService) GetDepartmentLabels(ctx context.Context, req *pb.GetDepartmentLabelRequest) (res *pb.GetDepartmentLabelResponse, err error) {
	res = &pb.GetDepartmentLabelResponse{}
	var values []*types.TypeValue[int64]
	if values, err = s.logic.GetLabels(ctx); err == nil {
		res.Data = make([]*pb.DepartmentLabelValue, 0, len(values))
		for _, row := range values {
			res.Data = append(res.Data, &pb.DepartmentLabelValue{
				Label: row.Label,
				Value: row.Value,
			})
		}
	}
	return
}

func (s *DepartmentService) recursiveDepartmentUser(parent int64, departments []*models.Department, users []*models.User) []*pb.DepartmentUserValue {
	values := make([]*pb.DepartmentUserValue, 0, len(departments))
	for _, row := range departments {
		if row.ParentId == parent {
			item := &pb.DepartmentUserValue{
				Label:    row.Name,
				Value:    strconv.FormatInt(row.Id, 10),
				Children: make([]*pb.DepartmentUserValue, 0),
			}
			item.Children = append(item.Children, s.recursiveDepartmentUser(row.Id, departments, users)...)
			for _, v := range users {
				if v.DeptId == row.Id {
					item.Children = append(item.Children, &pb.DepartmentUserValue{
						Label:  fmt.Sprintf("%s(%s)", v.Username, v.Uid),
						Value:  v.Uid,
						Isuser: true,
					})
				}
			}
			values = append(values, item)
		}
	}
	return values
}

func (s *DepartmentService) recursiveDepartmentLevel(parent int64, departments []*models.Department) []*pb.DepartmentLevelValue {
	values := make([]*pb.DepartmentLevelValue, 0, len(departments))
	for _, row := range departments {
		if row.ParentId == parent {
			item := &pb.DepartmentLevelValue{
				Label:    row.Name,
				Value:    row.Id,
				Children: make([]*pb.DepartmentLevelValue, 0),
			}
			item.Children = append(item.Children, s.recursiveDepartmentLevel(row.Id, departments)...)
			values = append(values, item)
		}
	}
	return values
}

func (s *DepartmentService) GetDepartmentUsers(ctx context.Context, req *pb.GetDepartmentUserRequest) (res *pb.GetDepartmentUserResponse, err error) {
	var (
		users       []*models.User
		departments []*models.Department
	)
	if departments, err = s.logic.GetDepartments(ctx); err != nil {
		return
	}
	if users, err = s.user.GeUsers(ctx); err != nil {
		return
	}
	res = &pb.GetDepartmentUserResponse{
		Data: s.recursiveDepartmentUser(0, departments, users),
	}
	return
}

func (s *DepartmentService) GetDepartmentLevelLabels(ctx context.Context, req *pb.GetDepartmentLevelLabelsRequest) (res *pb.GetDepartmentLevelLabelsResponse, err error) {
	var (
		departments []*models.Department
	)
	if departments, err = s.logic.GetDepartments(ctx); err != nil {
		return
	}
	res = &pb.GetDepartmentLevelLabelsResponse{
		Data: s.recursiveDepartmentLevel(0, departments),
	}
	return
}

func NewDepartmentService(cbs ...DepartmentOption) *DepartmentService {
	opts := &departmentOptions{}
	for _, cb := range cbs {
		cb(opts)
	}
	return &DepartmentService{
		opts:  opts,
		user:  logic.NewUserLogic(opts.db, opts.cache),
		logic: logic.NewDepartmentLogic(opts.db, opts.cache),
	}
}