package workspace

import (
	"context"

	"leafdev.top/Leaf/leaf-library-3/internal/dto/user"
	"leafdev.top/Leaf/leaf-library-3/internal/errs"

	"leafdev.top/Leaf/leaf-library-3/internal/dto"
	"leafdev.top/Leaf/leaf-library-3/internal/entity"
)

func (s *Service) Get(ctx context.Context, workspaceId dto.EntityId) (*entity.Workspace, error) {
	exists, err := s.Exists(ctx, workspaceId)

	if err != nil {
		return nil, err
	}

	if !exists {
		return nil, errs.ErrWorkspaceNotExists
	}

	return s.dao.WithContext(ctx).Workspace.Where(s.dao.Workspace.ID.Eq(workspaceId.Uint())).First()
}

func (s *Service) Exists(ctx context.Context, workspaceId dto.EntityId) (bool, error) {
	num, err := s.dao.WithContext(ctx).Workspace.Where(s.dao.Workspace.ID.Eq(workspaceId.Uint())).Count()

	return num > 0, err
}

func (s *Service) List(ctx context.Context, userId user.ID) ([]*entity.Workspace, error) {
	return s.dao.WithContext(ctx).Workspace.Where(s.dao.Workspace.UserId.Eq(userId.String())).Find()
}

func (s *Service) Create(ctx context.Context, userId user.ID, name string) (*entity.Workspace, error) {
	var workspace = &entity.Workspace{
		Name:   name,
		UserId: userId,
	}

	err := s.dao.WithContext(ctx).Workspace.Create(workspace)

	if err != nil {
		return nil, err
	}

	_, err = s.AddMember(ctx, userId, workspace)

	if err != nil {
		return nil, err
	}

	return workspace, nil
}

func (s *Service) ListMembers(ctx context.Context, workspaceEntity *entity.Workspace) ([]*entity.WorkspaceMember, error) {
	return s.dao.WithContext(ctx).WorkspaceMember.Where(s.dao.WorkspaceMember.WorkspaceId.Eq(workspaceEntity.ID.Uint())).Find()
}

func (s *Service) AddMember(ctx context.Context, userId user.ID, workspaceEntity *entity.Workspace) (*entity.WorkspaceMember, error) {
	memberExists, err := s.MemberExists(ctx, userId, workspaceEntity)
	if err != nil {
		return nil, err
	}

	if memberExists {
		return nil, errs.ErrMemberAlreadyExists
	}

	var workspaceMember = &entity.WorkspaceMember{
		UserId:      userId,
		WorkspaceId: workspaceEntity.ID,
	}

	err = s.dao.WithContext(ctx).WorkspaceMember.Create(workspaceMember)

	return workspaceMember, err
}

func (s *Service) RemoveMember(ctx context.Context, userId user.ID, workspaceEntity *entity.Workspace) error {
	memberExists, err := s.MemberExists(ctx, userId, workspaceEntity)
	if err != nil {
		return err
	}

	if !memberExists {
		return errs.ErrMemberNotExists
	}

	_, err = s.dao.WithContext(ctx).WorkspaceMember.
		Where(
			s.dao.WorkspaceMember.UserId.Eq(userId.String()),
			s.dao.WorkspaceMember.WorkspaceId.Eq(
				workspaceEntity.ID.Uint()),
		).
		Delete()

	return err
}

func (s *Service) MemberExists(ctx context.Context, userId user.ID, workspaceEntity *entity.Workspace) (bool, error) {
	if num, err := s.dao.WithContext(ctx).WorkspaceMember.Where(s.dao.WorkspaceMember.UserId.Eq(userId.String()), s.dao.WorkspaceMember.WorkspaceId.Eq(workspaceEntity.ID.Uint())).Count(); err != nil {
		return false, err
	} else {
		return num > 0, nil
	}
}

func (s *Service) DeleteWorkspace(ctx context.Context, workspaceId dto.EntityId) error {
	//	删除始终是一个复杂的工程，所以先标记为软删除
	_, err := s.dao.WithContext(ctx).Workspace.Where(s.dao.Workspace.ID.Eq(workspaceId.Uint())).Delete()

	return err
}

// IsMember 检查用户是否是工作空间的成员
func (s *Service) IsMember(ctx context.Context, userId user.ID, workspace *entity.Workspace) (bool, error) {
	return s.MemberExists(ctx, userId, workspace)
}