Enterprise-Knowledge-Base/internal/application/service/organization.go

package service

import (
	"context"
	"crypto/rand"
	"encoding/hex"
	"errors"
	"strings"
	"time"

	"github.com/Tencent/WeKnora/internal/application/repository"
	"github.com/Tencent/WeKnora/internal/logger"
	"github.com/Tencent/WeKnora/internal/types"
	"github.com/Tencent/WeKnora/internal/types/interfaces"
	"github.com/google/uuid"
)

// Default invite code validity in days; allowed values: 0 (never), 1, 7, 30
const DefaultInviteCodeValidityDays = 7

// DefaultMemberLimit is the default max members per organization (0 = unlimited)
const DefaultMemberLimit = 200

// ValidInviteCodeValidityDays are the allowed values for invite_code_validity_days
var ValidInviteCodeValidityDays = map[int]bool{0: true, 1: true, 7: true, 30: true}

var (
	ErrOrgNotFound           = errors.New("organization not found")
	ErrOrgPermissionDenied   = errors.New("permission denied for this organization")
	ErrCannotRemoveOwner     = errors.New("cannot remove organization owner")
	ErrCannotChangeOwnerRole = errors.New("cannot change organization owner role")
	ErrUserNotInOrg          = errors.New("user is not a member of this organization")
	ErrInvalidRole           = errors.New("invalid role")
	ErrInviteCodeExpired     = errors.New("invite code has expired")
	ErrInvalidValidityDays   = errors.New("invite_code_validity_days must be 0, 1, 7, or 30")
	ErrOrgMemberLimitReached = errors.New("organization member limit reached")
	ErrOrgMemberLimitTooLow  = errors.New("member limit cannot be lower than current member count")
)

// organizationService implements OrganizationService interface
type organizationService struct {
	orgRepo        interfaces.OrganizationRepository
	userRepo       interfaces.UserRepository
	shareRepo      interfaces.KBShareRepository
	agentShareRepo interfaces.AgentShareRepository
}

// NewOrganizationService creates a new organization service
func NewOrganizationService(
	orgRepo interfaces.OrganizationRepository,
	userRepo interfaces.UserRepository,
	shareRepo interfaces.KBShareRepository,
	agentShareRepo interfaces.AgentShareRepository,
) interfaces.OrganizationService {
	return &organizationService{
		orgRepo:        orgRepo,
		userRepo:       userRepo,
		shareRepo:      shareRepo,
		agentShareRepo: agentShareRepo,
	}
}

// resolveInviteExpiry returns expiresAt for the given validity days (0 = never, nil expiresAt).
func resolveInviteExpiry(validityDays int, now time.Time) *time.Time {
	if validityDays == 0 {
		return nil
	}
	t := now.AddDate(0, 0, validityDays)
	return &t
}

// CreateOrganization creates a new organization
func (s *organizationService) CreateOrganization(ctx context.Context, userID string, tenantID uint64, req *types.CreateOrganizationRequest) (*types.Organization, error) {
	logger.Infof(ctx, "Creating organization: %s by user: %s", req.Name, userID)

	validityDays := DefaultInviteCodeValidityDays
	if req.InviteCodeValidityDays != nil {
		if !ValidInviteCodeValidityDays[*req.InviteCodeValidityDays] {
			return nil, ErrInvalidValidityDays
		}
		validityDays = *req.InviteCodeValidityDays
	}
	memberLimit := DefaultMemberLimit
	if req.MemberLimit != nil {
		if *req.MemberLimit < 0 {
			return nil, errors.New("member_limit must be >= 0")
		}
		memberLimit = *req.MemberLimit
	}

	now := time.Now()
	org := &types.Organization{
		ID:                     uuid.New().String(),
		Name:                   req.Name,
		Description:            req.Description,
		Avatar:                 strings.TrimSpace(req.Avatar),
		OwnerID:                userID,
		InviteCode:             generateInviteCode(),
		InviteCodeExpiresAt:    resolveInviteExpiry(validityDays, now),
		InviteCodeValidityDays: validityDays,
		MemberLimit:            memberLimit,
		CreatedAt:              now,
		UpdatedAt:              now,
	}

	if err := s.orgRepo.Create(ctx, org); err != nil {
		logger.Errorf(ctx, "Failed to create organization: %v", err)
		return nil, err
	}

	// Add the creator as admin member
	member := &types.OrganizationMember{
		ID:             uuid.New().String(),
		OrganizationID: org.ID,
		UserID:         userID,
		TenantID:       tenantID,
		Role:           types.OrgRoleAdmin,
		CreatedAt:      time.Now(),
		UpdatedAt:      time.Now(),
	}

	if err := s.orgRepo.AddMember(ctx, member); err != nil {
		logger.Errorf(ctx, "Failed to add creator as member: %v", err)
		// Rollback organization creation
		_ = s.orgRepo.Delete(ctx, org.ID)
		return nil, err
	}

	logger.Infof(ctx, "Organization created successfully: %s", org.ID)
	return org, nil
}

// GetOrganization gets an organization by ID
func (s *organizationService) GetOrganization(ctx context.Context, id string) (*types.Organization, error) {
	org, err := s.orgRepo.GetByID(ctx, id)
	if err != nil {
		if errors.Is(err, repository.ErrOrganizationNotFound) {
			return nil, ErrOrgNotFound
		}
		return nil, err
	}
	return org, nil
}

// GetOrganizationByInviteCode gets an organization by invite code
func (s *organizationService) GetOrganizationByInviteCode(ctx context.Context, inviteCode string) (*types.Organization, error) {
	org, err := s.orgRepo.GetByInviteCode(ctx, inviteCode)
	if err != nil {
		if errors.Is(err, repository.ErrInviteCodeNotFound) {
			return nil, ErrOrgNotFound
		}
		if errors.Is(err, repository.ErrInviteCodeExpired) {
			return nil, ErrInviteCodeExpired
		}
		return nil, err
	}
	return org, nil
}

// ListUserOrganizations lists all organizations that a user belongs to
func (s *organizationService) ListUserOrganizations(ctx context.Context, userID string) ([]*types.Organization, error) {
	return s.orgRepo.ListByUserID(ctx, userID)
}

// UpdateOrganization updates an organization
func (s *organizationService) UpdateOrganization(ctx context.Context, id string, userID string, req *types.UpdateOrganizationRequest) (*types.Organization, error) {
	// Check if user is admin
	isAdmin, err := s.IsOrgAdmin(ctx, id, userID)
	if err != nil {
		return nil, err
	}
	if !isAdmin {
		return nil, ErrOrgPermissionDenied
	}

	org, err := s.orgRepo.GetByID(ctx, id)
	if err != nil {
		return nil, err
	}

	if req.Name != nil {
		org.Name = *req.Name
	}
	if req.Description != nil {
		org.Description = *req.Description
	}
	if req.Avatar != nil {
		org.Avatar = strings.TrimSpace(*req.Avatar)
	}
	if req.RequireApproval != nil {
		org.RequireApproval = *req.RequireApproval
	}
	if req.Searchable != nil {
		org.Searchable = *req.Searchable
	}
	if req.InviteCodeValidityDays != nil {
		if !ValidInviteCodeValidityDays[*req.InviteCodeValidityDays] {
			return nil, ErrInvalidValidityDays
		}
		org.InviteCodeValidityDays = *req.InviteCodeValidityDays
	}
	if req.MemberLimit != nil {
		if *req.MemberLimit < 0 {
			return nil, errors.New("member_limit must be >= 0")
		}
		if *req.MemberLimit > 0 {
			count, err := s.orgRepo.CountMembers(ctx, id)
			if err != nil {
				return nil, err
			}
			if int64(*req.MemberLimit) < count {
				return nil, ErrOrgMemberLimitTooLow
			}
		}
		org.MemberLimit = *req.MemberLimit
	}
	org.UpdatedAt = time.Now()

	if err := s.orgRepo.Update(ctx, org); err != nil {
		return nil, err
	}

	return org, nil
}

// SearchSearchableOrganizations returns searchable (discoverable) organizations for the current user
func (s *organizationService) SearchSearchableOrganizations(ctx context.Context, userID string, query string, limit int) (*types.ListSearchableOrganizationsResponse, error) {
	if limit <= 0 {
		limit = 20
	}
	orgs, err := s.orgRepo.ListSearchable(ctx, query, limit)
	if err != nil {
		return nil, err
	}
	memberCounts := make(map[string]int64)
	shareCounts := make(map[string]int64)
	agentShareCounts := make(map[string]int)
	memberOrgIDs := make(map[string]bool)
	for _, org := range orgs {
		if mc, err := s.orgRepo.CountMembers(ctx, org.ID); err == nil {
			memberCounts[org.ID] = mc
		}
		shares, _ := s.shareRepo.ListByOrganization(ctx, org.ID)
		shareCounts[org.ID] = int64(len(shares))
		if agentShares, err := s.agentShareRepo.ListByOrganization(ctx, org.ID); err == nil {
			agentShareCounts[org.ID] = len(agentShares)
		}
		_, err := s.orgRepo.GetMember(ctx, org.ID, userID)
		memberOrgIDs[org.ID] = (err == nil)
	}
	items := make([]types.SearchableOrganizationItem, 0, len(orgs))
	for _, org := range orgs {
		items = append(items, types.SearchableOrganizationItem{
			ID:              org.ID,
			Name:            org.Name,
			Description:     org.Description,
			Avatar:          org.Avatar,
			MemberCount:     int(memberCounts[org.ID]),
			MemberLimit:     org.MemberLimit,
			ShareCount:      int(shareCounts[org.ID]),
			AgentShareCount: agentShareCounts[org.ID],
			IsAlreadyMember: memberOrgIDs[org.ID],
			RequireApproval: org.RequireApproval,
		})
	}
	return &types.ListSearchableOrganizationsResponse{
		Organizations: items,
		Total:         int64(len(items)),
	}, nil
}

// JoinByOrganizationID joins a searchable organization by ID (no invite code required)
func (s *organizationService) JoinByOrganizationID(ctx context.Context, orgID string, userID string, tenantID uint64, message string, requestedRole types.OrgMemberRole) (*types.Organization, error) {
	org, err := s.orgRepo.GetByID(ctx, orgID)
	if err != nil {
		if errors.Is(err, repository.ErrOrganizationNotFound) {
			return nil, ErrOrgNotFound
		}
		return nil, err
	}
	if !org.Searchable {
		return nil, ErrOrgPermissionDenied // or a dedicated "org not discoverable" error
	}
	_, err = s.orgRepo.GetMember(ctx, orgID, userID)
	if err == nil {
		return org, nil // already member
	}
	// Validate requested role if provided
	if requestedRole != "" && !requestedRole.IsValid() {
		return nil, ErrInvalidRole
	}
	// Default to viewer if not specified
	if requestedRole == "" {
		requestedRole = types.OrgRoleViewer
	}
	if org.RequireApproval {
		_, err = s.SubmitJoinRequest(ctx, orgID, userID, tenantID, message, requestedRole)
		if err != nil {
			return nil, err
		}
		return org, nil
	}
	// Direct join using invite code flow logic (add member)
	_, err = s.JoinByInviteCode(ctx, org.InviteCode, userID, tenantID)
	if err != nil {
		return nil, err
	}
	return org, nil
}

// DeleteOrganization deletes an organization
func (s *organizationService) DeleteOrganization(ctx context.Context, id string, userID string) error {
	org, err := s.orgRepo.GetByID(ctx, id)
	if err != nil {
		return err
	}

	// Only owner can delete organization
	if org.OwnerID != userID {
		return ErrOrgPermissionDenied
	}

	// Remove all KB shares for this org so members no longer see associated knowledge bases
	if err := s.shareRepo.DeleteByOrganizationID(ctx, id); err != nil {
		logger.Warnf(ctx, "Failed to delete KB shares for organization %s: %v", id, err)
	}
	if err := s.agentShareRepo.DeleteByOrganizationID(ctx, id); err != nil {
		logger.Warnf(ctx, "Failed to delete agent shares for organization %s: %v", id, err)
	}

	return s.orgRepo.Delete(ctx, id)
}

// AddMember adds a member to an organization
func (s *organizationService) AddMember(ctx context.Context, orgID string, userID string, tenantID uint64, role types.OrgMemberRole) error {
	if !role.IsValid() {
		return ErrInvalidRole
	}

	org, err := s.orgRepo.GetByID(ctx, orgID)
	if err != nil {
		return err
	}
	if org.MemberLimit > 0 {
		count, errCount := s.orgRepo.CountMembers(ctx, orgID)
		if errCount != nil {
			return errCount
		}
		if count >= int64(org.MemberLimit) {
			return ErrOrgMemberLimitReached
		}
	}

	member := &types.OrganizationMember{
		ID:             uuid.New().String(),
		OrganizationID: orgID,
		UserID:         userID,
		TenantID:       tenantID,
		Role:           role,
		CreatedAt:      time.Now(),
		UpdatedAt:      time.Now(),
	}

	return s.orgRepo.AddMember(ctx, member)
}

// RemoveMember removes a member from an organization.
// When operatorUserID == memberUserID, it is "leave" (self-removal) and does not require admin.
// When removing another member, operator must be admin.
func (s *organizationService) RemoveMember(ctx context.Context, orgID string, memberUserID string, operatorUserID string) error {
	// Check if trying to remove owner
	org, err := s.orgRepo.GetByID(ctx, orgID)
	if err != nil {
		return err
	}
	if org.OwnerID == memberUserID {
		return ErrCannotRemoveOwner
	}

	// Self-removal (leave): allow any member to leave
	if operatorUserID == memberUserID {
		return s.orgRepo.RemoveMember(ctx, orgID, memberUserID)
	}

	// Removing another member: require operator to be admin
	isAdmin, err := s.IsOrgAdmin(ctx, orgID, operatorUserID)
	if err != nil {
		return err
	}
	if !isAdmin {
		return ErrOrgPermissionDenied
	}

	return s.orgRepo.RemoveMember(ctx, orgID, memberUserID)
}

// UpdateMemberRole updates a member's role
func (s *organizationService) UpdateMemberRole(ctx context.Context, orgID string, memberUserID string, role types.OrgMemberRole, operatorUserID string) error {
	if !role.IsValid() {
		return ErrInvalidRole
	}

	// Check if operator is admin
	isAdmin, err := s.IsOrgAdmin(ctx, orgID, operatorUserID)
	if err != nil {
		return err
	}
	if !isAdmin {
		return ErrOrgPermissionDenied
	}

	// Check if trying to change owner's role
	org, err := s.orgRepo.GetByID(ctx, orgID)
	if err != nil {
		return err
	}
	if org.OwnerID == memberUserID {
		return ErrCannotChangeOwnerRole
	}

	return s.orgRepo.UpdateMemberRole(ctx, orgID, memberUserID, role)
}

// ListMembers lists all members of an organization
func (s *organizationService) ListMembers(ctx context.Context, orgID string) ([]*types.OrganizationMember, error) {
	return s.orgRepo.ListMembers(ctx, orgID)
}

// GetMember gets a specific member of an organization
func (s *organizationService) GetMember(ctx context.Context, orgID string, userID string) (*types.OrganizationMember, error) {
	member, err := s.orgRepo.GetMember(ctx, orgID, userID)
	if err != nil {
		if errors.Is(err, repository.ErrOrgMemberNotFound) {
			return nil, ErrUserNotInOrg
		}
		return nil, err
	}
	return member, nil
}

// GenerateInviteCode generates a new invite code for an organization
func (s *organizationService) GenerateInviteCode(ctx context.Context, orgID string, userID string) (string, error) {
	// Check if user is admin
	isAdmin, err := s.IsOrgAdmin(ctx, orgID, userID)
	if err != nil {
		return "", err
	}
	if !isAdmin {
		return "", ErrOrgPermissionDenied
	}

	org, err := s.orgRepo.GetByID(ctx, orgID)
	if err != nil {
		return "", err
	}

	validityDays := org.InviteCodeValidityDays
	if validityDays != 0 && !ValidInviteCodeValidityDays[validityDays] {
		validityDays = DefaultInviteCodeValidityDays
	}
	// 0 = never expire (expiresAt nil); 1/7/30 = that many days

	inviteCode := generateInviteCode()
	now := time.Now()
	expiresAt := resolveInviteExpiry(validityDays, now)
	if err := s.orgRepo.UpdateInviteCode(ctx, orgID, inviteCode, expiresAt); err != nil {
		return "", err
	}

	return inviteCode, nil
}

// JoinByInviteCode allows a user to join an organization via invite code
func (s *organizationService) JoinByInviteCode(ctx context.Context, inviteCode string, userID string, tenantID uint64) (*types.Organization, error) {
	org, err := s.orgRepo.GetByInviteCode(ctx, inviteCode)
	if err != nil {
		if errors.Is(err, repository.ErrInviteCodeNotFound) {
			return nil, ErrOrgNotFound
		}
		if errors.Is(err, repository.ErrInviteCodeExpired) {
			return nil, ErrInviteCodeExpired
		}
		return nil, err
	}

	// check if the organization need approval
	if org.RequireApproval {
		logger.Infof(ctx, "Organization %s requires approval", org.ID)
		return nil, ErrOrgPermissionDenied
	}

	// Check if user is already a member
	_, err = s.orgRepo.GetMember(ctx, org.ID, userID)
	if err == nil {
		// User is already a member, just return the organization
		return org, nil
	}
	if !errors.Is(err, repository.ErrOrgMemberNotFound) {
		return nil, err
	}

	// Check member limit (0 = unlimited)
	if org.MemberLimit > 0 {
		count, errCount := s.orgRepo.CountMembers(ctx, org.ID)
		if errCount != nil {
			return nil, errCount
		}
		if count >= int64(org.MemberLimit) {
			return nil, ErrOrgMemberLimitReached
		}
	}

	// Add user as viewer by default
	member := &types.OrganizationMember{
		ID:             uuid.New().String(),
		OrganizationID: org.ID,
		UserID:         userID,
		TenantID:       tenantID,
		Role:           types.OrgRoleViewer,
		CreatedAt:      time.Now(),
		UpdatedAt:      time.Now(),
	}

	if err := s.orgRepo.AddMember(ctx, member); err != nil {
		return nil, err
	}

	logger.Infof(ctx, "User %s joined organization %s via invite code", userID, org.ID)
	return org, nil
}

// IsOrgAdmin checks if a user is an admin of an organization
func (s *organizationService) IsOrgAdmin(ctx context.Context, orgID string, userID string) (bool, error) {
	member, err := s.orgRepo.GetMember(ctx, orgID, userID)
	if err != nil {
		if errors.Is(err, repository.ErrOrgMemberNotFound) {
			return false, nil
		}
		return false, err
	}
	return member.Role == types.OrgRoleAdmin, nil
}

// GetUserRoleInOrg gets a user's role in an organization
func (s *organizationService) GetUserRoleInOrg(ctx context.Context, orgID string, userID string) (types.OrgMemberRole, error) {
	member, err := s.orgRepo.GetMember(ctx, orgID, userID)
	if err != nil {
		if errors.Is(err, repository.ErrOrgMemberNotFound) {
			return "", ErrUserNotInOrg
		}
		return "", err
	}
	return member.Role, nil
}

// generateInviteCode generates a random 16-character invite code
func generateInviteCode() string {
	bytes := make([]byte, 8)
	_, _ = rand.Read(bytes)
	return hex.EncodeToString(bytes)
}

// ----------------
// Join Requests
// ----------------

var (
	ErrPendingRequestExists    = errors.New("pending request already exists")
	ErrJoinRequestNotFound     = errors.New("join request not found")
	ErrCannotUpgradeToSameRole = errors.New("cannot request upgrade to same or lower role")
	ErrAlreadyAdmin            = errors.New("user is already an admin")
)

// SubmitJoinRequest submits a request to join an organization
func (s *organizationService) SubmitJoinRequest(ctx context.Context, orgID string, userID string, tenantID uint64, message string, requestedRole types.OrgMemberRole) (*types.OrganizationJoinRequest, error) {
	logger.Infof(ctx, "User %s submitting join request for organization %s", userID, orgID)

	// Check if there's already a pending join request
	existing, err := s.orgRepo.GetPendingRequestByType(ctx, orgID, userID, types.JoinRequestTypeJoin)
	if err == nil && existing != nil {
		return nil, ErrPendingRequestExists
	}

	// Reject if organization is already at member limit
	org, err := s.orgRepo.GetByID(ctx, orgID)
	if err != nil {
		if errors.Is(err, repository.ErrOrganizationNotFound) {
			return nil, ErrOrgNotFound
		}
		return nil, err
	}
	if org.MemberLimit > 0 {
		count, errCount := s.orgRepo.CountMembers(ctx, orgID)
		if errCount != nil {
			return nil, errCount
		}
		if count >= int64(org.MemberLimit) {
			return nil, ErrOrgMemberLimitReached
		}
	}

	// Default to viewer if role is empty or invalid
	if requestedRole == "" || !requestedRole.IsValid() {
		requestedRole = types.OrgRoleViewer
	}

	request := &types.OrganizationJoinRequest{
		ID:             uuid.New().String(),
		OrganizationID: orgID,
		UserID:         userID,
		TenantID:       tenantID,
		RequestType:    types.JoinRequestTypeJoin,
		RequestedRole:  requestedRole,
		Status:         types.JoinRequestStatusPending,
		Message:        message,
		CreatedAt:      time.Now(),
		UpdatedAt:      time.Now(),
	}

	if err := s.orgRepo.CreateJoinRequest(ctx, request); err != nil {
		return nil, err
	}

	logger.Infof(ctx, "Join request %s created for organization %s by user %s", request.ID, orgID, userID)
	return request, nil
}

// ListJoinRequests lists all join requests for an organization
func (s *organizationService) ListJoinRequests(ctx context.Context, orgID string) ([]*types.OrganizationJoinRequest, error) {
	return s.orgRepo.ListJoinRequests(ctx, orgID, "")
}

// CountPendingJoinRequests returns the number of pending join requests for an organization
func (s *organizationService) CountPendingJoinRequests(ctx context.Context, orgID string) (int64, error) {
	return s.orgRepo.CountJoinRequests(ctx, orgID, types.JoinRequestStatusPending)
}

// ReviewJoinRequest reviews a join request or upgrade request (approve or reject).
// When approving, assignRole overrides the applicant's requested role if set; otherwise uses request.RequestedRole or viewer.
func (s *organizationService) ReviewJoinRequest(ctx context.Context, orgID string, requestID string, approved bool, reviewerID string, message string, assignRole *types.OrgMemberRole) error {
	request, err := s.orgRepo.GetJoinRequestByID(ctx, requestID)
	if err != nil {
		return ErrJoinRequestNotFound
	}
	if request.OrganizationID != orgID {
		return ErrJoinRequestNotFound
	}

	if request.Status != types.JoinRequestStatusPending {
		return errors.New("request has already been reviewed")
	}

	var status types.JoinRequestStatus
	if approved {
		status = types.JoinRequestStatusApproved

		// Role to assign: admin override > applicant's requested role > viewer
		role := types.OrgRoleViewer
		if assignRole != nil && assignRole.IsValid() {
			role = *assignRole
		} else if request.RequestedRole != "" && request.RequestedRole.IsValid() {
			role = request.RequestedRole
		}

		// Handle based on request type
		if request.RequestType == types.JoinRequestTypeUpgrade {
			// Upgrade: update existing member's role
			if err := s.orgRepo.UpdateMemberRole(ctx, request.OrganizationID, request.UserID, role); err != nil {
				return err
			}
			logger.Infof(ctx, "Upgrade request %s approved, user %s role updated to %s in organization %s", requestID, request.UserID, role, request.OrganizationID)
		} else {
			// Join: check member limit then add new member
			org, errOrg := s.orgRepo.GetByID(ctx, request.OrganizationID)
			if errOrg != nil {
				return errOrg
			}
			if org.MemberLimit > 0 {
				count, errCount := s.orgRepo.CountMembers(ctx, request.OrganizationID)
				if errCount != nil {
					return errCount
				}
				if count >= int64(org.MemberLimit) {
					return ErrOrgMemberLimitReached
				}
			}
			member := &types.OrganizationMember{
				ID:             uuid.New().String(),
				OrganizationID: request.OrganizationID,
				UserID:         request.UserID,
				TenantID:       request.TenantID,
				Role:           role,
				CreatedAt:      time.Now(),
				UpdatedAt:      time.Now(),
			}
			if err := s.orgRepo.AddMember(ctx, member); err != nil {
				return err
			}
			logger.Infof(ctx, "Join request %s approved, user %s added to organization %s with role %s", requestID, request.UserID, request.OrganizationID, role)
		}
	} else {
		status = types.JoinRequestStatusRejected
		logger.Infof(ctx, "Request %s rejected for user %s", requestID, request.UserID)
	}

	return s.orgRepo.UpdateJoinRequestStatus(ctx, requestID, status, reviewerID, message)
}

// RequestRoleUpgrade submits a request to upgrade role in an organization
func (s *organizationService) RequestRoleUpgrade(ctx context.Context, orgID string, userID string, tenantID uint64, requestedRole types.OrgMemberRole, message string) (*types.OrganizationJoinRequest, error) {
	logger.Infof(ctx, "User %s submitting role upgrade request for organization %s to role %s", userID, orgID, requestedRole)

	// Check if user is a member
	member, err := s.orgRepo.GetMember(ctx, orgID, userID)
	if err != nil {
		if errors.Is(err, repository.ErrOrgMemberNotFound) {
			return nil, ErrUserNotInOrg
		}
		return nil, err
	}

	// Validate the requested role
	if !requestedRole.IsValid() {
		return nil, ErrInvalidRole
	}

	// Check if already admin
	if member.Role == types.OrgRoleAdmin {
		return nil, ErrAlreadyAdmin
	}

	// Check if requested role is higher than current role
	if !requestedRole.HasPermission(member.Role) || requestedRole == member.Role {
		return nil, ErrCannotUpgradeToSameRole
	}

	// Check if there's already a pending upgrade request
	existing, err := s.orgRepo.GetPendingRequestByType(ctx, orgID, userID, types.JoinRequestTypeUpgrade)
	if err == nil && existing != nil {
		return nil, ErrPendingRequestExists
	}

	request := &types.OrganizationJoinRequest{
		ID:             uuid.New().String(),
		OrganizationID: orgID,
		UserID:         userID,
		TenantID:       tenantID,
		RequestType:    types.JoinRequestTypeUpgrade,
		PrevRole:       member.Role,
		RequestedRole:  requestedRole,
		Status:         types.JoinRequestStatusPending,
		Message:        message,
		CreatedAt:      time.Now(),
		UpdatedAt:      time.Now(),
	}

	if err := s.orgRepo.CreateJoinRequest(ctx, request); err != nil {
		return nil, err
	}

	logger.Infof(ctx, "Role upgrade request %s created for organization %s by user %s (from %s to %s)", request.ID, orgID, userID, member.Role, requestedRole)
	return request, nil
}

// GetPendingUpgradeRequest gets a pending upgrade request for a user in an organization
func (s *organizationService) GetPendingUpgradeRequest(ctx context.Context, orgID string, userID string) (*types.OrganizationJoinRequest, error) {
	request, err := s.orgRepo.GetPendingRequestByType(ctx, orgID, userID, types.JoinRequestTypeUpgrade)
	if err != nil {
		if errors.Is(err, repository.ErrJoinRequestNotFound) {
			return nil, ErrJoinRequestNotFound
		}
		return nil, err
	}
	return request, nil
}