package store

import (
	"context"
	"fmt"

	"git.linuxforward.com/byom/byom-core/common"
	"github.com/google/uuid"
	"gorm.io/gorm"
)

//CRUD methods for the workspace

// CreateWorkspace creates a new workspace
func (s *DataStore) CreateWorkspace(ctx context.Context, w *common.Workspace) error {
	result := s.db.Create(w)
	if result.Error != nil {
		return fmt.Errorf("create workspace: %w", result.Error)
	}
	return nil
}

// GetWorkspace gets a workspace by ID
func (s *DataStore) GetWorkspace(ctx context.Context, id string) (*common.Workspace, error) {
	var workspace common.Workspace
	result := s.db.First(&workspace, id)
	if result.Error != nil {
		return nil, fmt.Errorf("get workspace: %w", result.Error)
	}
	return &workspace, nil
}

// UpdateWorkspace updates a workspace
func (s *DataStore) UpdateWorkspace(ctx context.Context, w *common.Workspace) error {
	result := s.db.Save(w)
	if result.Error != nil {
		return fmt.Errorf("update workspace: %w", result.Error)
	}
	return nil
}

// DeleteWorkspace deletes a workspace
func (s *DataStore) DeleteWorkspace(ctx context.Context, id string) error {
	result := s.db.Delete(&common.Workspace{}, id)
	if result.Error != nil {
		return fmt.Errorf("delete workspace: %w", result.Error)
	}
	return nil
}

// GetWorkspaces gets all workspaces
func (s *DataStore) GetWorkspaces(ctx context.Context) ([]common.Workspace, error) {
	var workspaces []common.Workspace
	result := s.db.Find(&workspaces)
	if result.Error != nil {
		return nil, fmt.Errorf("get workspaces: %w", result.Error)
	}
	return workspaces, nil
}

// GetWorkspacesByUserID gets all workspaces by user ID
func (s *DataStore) GetWorkspacesByUserID(ctx context.Context, userID uuid.UUID) ([]common.Workspace, error) {
	var workspaces []common.Workspace
	err := s.db.Model(&common.User{ID: userID}).
		Association("Workspaces").
		Find(&workspaces)

	if err != nil {
		return nil, fmt.Errorf("get workspaces by user ID: %w", err)
	}
	return workspaces, nil
}

// GetWorkspaceByUserID gets a workspace by user ID
func (s *DataStore) GetWorkspaceByUserID(ctx context.Context, userID, workspaceID uuid.UUID) (*common.Workspace, error) {
	var workspace common.Workspace
	err := s.db.Model(&common.User{ID: userID}).
		Association("Workspaces").
		Find(&workspace, workspaceID)

	if err != nil {
		return nil, fmt.Errorf("get workspace by user ID: %w", err)
	}
	return &workspace, nil
}

// AddUserToWorkspace adds a user to a workspace
func (s *DataStore) AddUserToWorkspace(ctx context.Context, userID, workspaceID uuid.UUID, role string) error {
	uwr := common.UserWorkspaceRole{
		UserID:      userID,
		WorkspaceID: workspaceID,
		Role:        role,
	}

	result := s.db.Create(&uwr)
	if result.Error != nil {
		return fmt.Errorf("add user to workspace: %w", result.Error)
	}
	return nil
}

// AddUserToWorkspaceTx adds a user to a workspace in a transaction
func (s *DataStore) AddUserToWorkspaceTx(ctx context.Context, tx *gorm.DB, role string, userID, workspaceID uuid.UUID) error {
	uwr := common.UserWorkspaceRole{
		UserID:      userID,
		WorkspaceID: workspaceID,
		Role:        role,
	}

	result := tx.Create(&uwr)
	if result.Error != nil {
		return fmt.Errorf("add user to workspace in transaction: %w", result.Error)
	}
	return nil
}

// GetUserWorkspaceRole gets a user's role in a workspace
func (s *DataStore) GetUserWorkspaceRole(ctx context.Context, userID, workspaceID string) (*common.UserWorkspaceRole, error) {
	var uwr common.UserWorkspaceRole
	result := s.db.Where("user_id = ? AND workspace_id = ?", userID, workspaceID).First(&uwr)
	if result.Error != nil {
		return nil, fmt.Errorf("get user workspace role: %w", result.Error)
	}
	return &uwr, nil
}

// UpdateUserWorkspaceRole updates a user's role in a workspace
func (s *DataStore) UpdateUserWorkspaceRole(ctx context.Context, userID, workspaceID, newRole string) error {
	result := s.db.Model(&common.UserWorkspaceRole{}).
		Where("user_id = ? AND workspace_id = ?", userID, workspaceID).
		Update("role", newRole)
	if result.Error != nil {
		return fmt.Errorf("update user workspace role: %w", result.Error)
	}
	return nil
}

// DeleteUserFromWorkspace deletes a user from a workspace
func (s *DataStore) DeleteUserFromWorkspace(ctx context.Context, userID, workspaceID string) error {
	result := s.db.Where("user_id = ? AND workspace_id = ?", userID, workspaceID).Delete(&common.UserWorkspaceRole{})
	if result.Error != nil {
		return fmt.Errorf("delete user from workspace: %w", result.Error)
	}
	return nil
}

// GetWorkspaceUsers gets all users in a workspace
func (s *DataStore) GetWorkspaceUsers(ctx context.Context, workspaceID string) ([]common.User, error) {
	var users []common.User
	workspaceUUID, err := uuid.Parse(workspaceID)
	if err != nil {
		return nil, fmt.Errorf("invalid workspace ID: %w", err)
	}
	err = s.db.Model(&common.Workspace{ID: workspaceUUID}).
		Association("Users").
		Find(&users)

	if err != nil {
		return nil, fmt.Errorf("get workspace users: %w", err)
	}
	return users, nil
}