path: root/pkg/semantic/project_manager.go

package semantic

import (
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"
)

// ProjectManager manages project context and boundaries
type ProjectManager struct {
	rootPath      string
	config        *ProjectConfig
	languageFiles map[string][]string // language -> file_paths
	excludeRules  []string
	mu            sync.RWMutex
}

// FileInfo represents information about a file
type FileInfo struct {
	Path    string
	Size    int64
	ModTime time.Time
	IsDir   bool
}

// NewProjectManager creates a new project manager
func NewProjectManager() *ProjectManager {
	return &ProjectManager{
		languageFiles: make(map[string][]string),
		excludeRules: []string{
			"**/node_modules/**",
			"**/vendor/**",
			"**/.git/**",
			"**/target/**",
			"**/dist/**",
			"**/build/**",
			"**/*.min.js",
			"**/*.min.css",
		},
	}
}

// DiscoverProject initializes project discovery from a root path
func (pm *ProjectManager) DiscoverProject(rootPath string) error {
	pm.mu.Lock()
	defer pm.mu.Unlock()

	absPath, err := filepath.Abs(rootPath)
	if err != nil {
		return fmt.Errorf("failed to get absolute path: %w", err)
	}

	pm.rootPath = absPath

	// Initialize project config
	pm.config = &ProjectConfig{
		Name:            filepath.Base(absPath),
		RootPath:        absPath,
		Languages:       []string{},
		ExcludePatterns: pm.excludeRules,
		IncludePatterns: []string{"**/*"},
		CustomSettings:  make(map[string]string),
	}

	// Scan for files and detect languages
	if err := pm.scanProject(); err != nil {
		return fmt.Errorf("failed to scan project: %w", err)
	}

	return nil
}

// scanProject scans the project and categorizes files by language
func (pm *ProjectManager) scanProject() error {
	pm.languageFiles = make(map[string][]string)

	err := filepath.WalkDir(pm.rootPath, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return nil // Continue on errors
		}

		// Skip excluded paths
		if pm.shouldExclude(path) {
			if d.IsDir() {
				return filepath.SkipDir
			}
			return nil
		}

		// Only process files
		if d.IsDir() {
			return nil
		}

		// Detect language and add to appropriate list
		language := pm.detectLanguage(path)
		if language != "" {
			pm.languageFiles[language] = append(pm.languageFiles[language], path)
			
			// Add to supported languages if not already present
			found := false
			for _, lang := range pm.config.Languages {
				if lang == language {
					found = true
					break
				}
			}
			if !found {
				pm.config.Languages = append(pm.config.Languages, language)
			}
		}

		return nil
	})

	return err
}

// shouldExclude checks if a path should be excluded based on patterns
func (pm *ProjectManager) shouldExclude(path string) bool {
	relPath, err := filepath.Rel(pm.rootPath, path)
	if err != nil {
		return true
	}

	for _, pattern := range pm.excludeRules {
		if matched, _ := filepath.Match(pattern, relPath); matched {
			return true
		}

		// Handle ** patterns manually
		if strings.Contains(pattern, "**") {
			pattern = strings.ReplaceAll(pattern, "**", "*")
			if matched, _ := filepath.Match(pattern, relPath); matched {
				return true
			}
		}

		// Check if any parent directory matches
		parts := strings.Split(relPath, string(filepath.Separator))
		for i := range parts {
			partialPath := strings.Join(parts[:i+1], string(filepath.Separator))
			if matched, _ := filepath.Match(pattern, partialPath); matched {
				return true
			}
		}
	}

	return false
}

// detectLanguage detects the programming language from file extension
func (pm *ProjectManager) detectLanguage(filePath string) string {
	ext := strings.ToLower(filepath.Ext(filePath))

	for language, config := range DefaultLanguageServers {
		for _, supportedExt := range config.FileExts {
			if ext == supportedExt {
				return language
			}
		}
	}

	return ""
}

// GetSupportedLanguages returns list of detected languages in the project
func (pm *ProjectManager) GetSupportedLanguages() []string {
	pm.mu.RLock()
	defer pm.mu.RUnlock()

	if pm.config == nil {
		return []string{}
	}

	return pm.config.Languages
}

// GetFilesByLanguage returns all files for a specific language
func (pm *ProjectManager) GetFilesByLanguage(language string) []string {
	pm.mu.RLock()
	defer pm.mu.RUnlock()

	files, exists := pm.languageFiles[language]
	if !exists {
		return []string{}
	}

	// Return a copy to avoid race conditions
	result := make([]string, len(files))
	copy(result, files)
	return result
}

// GetFilesInDirectory returns all supported files in a directory
func (pm *ProjectManager) GetFilesInDirectory(dirPath string) []string {
	pm.mu.RLock()
	defer pm.mu.RUnlock()

	var files []string

	// Convert to absolute path if relative
	if !filepath.IsAbs(dirPath) {
		dirPath = filepath.Join(pm.rootPath, dirPath)
	}

	// Walk the directory
	filepath.WalkDir(dirPath, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return nil
		}

		if d.IsDir() {
			return nil
		}

		// Check if file is supported
		if pm.detectLanguage(path) != "" && !pm.shouldExclude(path) {
			files = append(files, path)
		}

		return nil
	})

	return files
}

// IsFileInProject checks if a file is within project boundaries
func (pm *ProjectManager) IsFileInProject(filePath string) bool {
	pm.mu.RLock()
	defer pm.mu.RUnlock()

	if pm.rootPath == "" {
		return false
	}

	absPath, err := filepath.Abs(filePath)
	if err != nil {
		return false
	}

	// Check if file is under project root
	relPath, err := filepath.Rel(pm.rootPath, absPath)
	if err != nil || strings.HasPrefix(relPath, "..") {
		return false
	}

	// Check if file should be excluded
	return !pm.shouldExclude(absPath)
}

// ReadFile reads the contents of a file
func (pm *ProjectManager) ReadFile(filePath string) ([]byte, error) {
	if !pm.IsFileInProject(filePath) {
		return nil, fmt.Errorf("file is outside project boundaries: %s", filePath)
	}

	return os.ReadFile(filePath)
}

// GetFileInfo gets information about a file
func (pm *ProjectManager) GetFileInfo(filePath string) (*FileInfo, error) {
	if !pm.IsFileInProject(filePath) {
		return nil, fmt.Errorf("file is outside project boundaries: %s", filePath)
	}

	stat, err := os.Stat(filePath)
	if err != nil {
		return nil, fmt.Errorf("failed to stat file: %w", err)
	}

	return &FileInfo{
		Path:    filePath,
		Size:    stat.Size(),
		ModTime: stat.ModTime(),
		IsDir:   stat.IsDir(),
	}, nil
}

// GetProjectStats returns statistics about the project
func (pm *ProjectManager) GetProjectStats() map[string]interface{} {
	pm.mu.RLock()
	defer pm.mu.RUnlock()

	stats := make(map[string]interface{})
	
	if pm.config != nil {
		stats["name"] = pm.config.Name
		stats["root_path"] = pm.config.RootPath
		stats["languages"] = pm.config.Languages
	}

	stats["files_by_language"] = make(map[string]int)
	totalFiles := 0
	
	for language, files := range pm.languageFiles {
		count := len(files)
		stats["files_by_language"].(map[string]int)[language] = count
		totalFiles += count
	}
	
	stats["total_files"] = totalFiles

	return stats
}

// GetRootPath returns the project root path
func (pm *ProjectManager) GetRootPath() string {
	pm.mu.RLock()
	defer pm.mu.RUnlock()
	return pm.rootPath
}

// GetConfig returns the project configuration
func (pm *ProjectManager) GetConfig() *ProjectConfig {
	pm.mu.RLock()
	defer pm.mu.RUnlock()
	
	if pm.config == nil {
		return nil
	}

	// Return a copy
	config := *pm.config
	config.Languages = make([]string, len(pm.config.Languages))
	copy(config.Languages, pm.config.Languages)
	
	config.ExcludePatterns = make([]string, len(pm.config.ExcludePatterns))
	copy(config.ExcludePatterns, pm.config.ExcludePatterns)
	
	config.IncludePatterns = make([]string, len(pm.config.IncludePatterns))
	copy(config.IncludePatterns, pm.config.IncludePatterns)
	
	config.CustomSettings = make(map[string]string)
	for k, v := range pm.config.CustomSettings {
		config.CustomSettings[k] = v
	}

	return &config
}

// SetExcludePatterns sets custom exclude patterns
func (pm *ProjectManager) SetExcludePatterns(patterns []string) {
	pm.mu.Lock()
	defer pm.mu.Unlock()

	pm.excludeRules = patterns
	if pm.config != nil {
		pm.config.ExcludePatterns = patterns
	}

	// Re-scan project with new patterns
	if pm.rootPath != "" {
		pm.scanProject()
	}
}

// AddExcludePattern adds a new exclude pattern
func (pm *ProjectManager) AddExcludePattern(pattern string) {
	pm.mu.Lock()
	defer pm.mu.Unlock()

	pm.excludeRules = append(pm.excludeRules, pattern)
	if pm.config != nil {
		pm.config.ExcludePatterns = append(pm.config.ExcludePatterns, pattern)
	}
}

// Shutdown gracefully shuts down the project manager
func (pm *ProjectManager) Shutdown() error {
	pm.mu.Lock()
	defer pm.mu.Unlock()

	// Clear all data
	pm.languageFiles = make(map[string][]string)
	pm.config = nil
	pm.rootPath = ""

	return nil
}