main.go

package main

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"github.com/drpaneas/codesearch/internal/config"
	"github.com/drpaneas/codesearch/pkg/analysis"
	"github.com/drpaneas/codesearch/pkg/errors"
)

func main() {
	// Parse command line arguments first to determine verbosity
	mode, query, projectPath, analysisConfig := parseArgs()

	// Show header based on verbosity level
	if analysisConfig.VerbosityLevel >= config.VerbosityNormal {
		fmt.Println("🎯 CODESEARCH - Advanced Code Analysis Tool")
		fmt.Println("==========================================")
	}

	// Check for API key
	apiKey := os.Getenv("ANTHROPIC_API_KEY")
	if apiKey == "" {
		if analysisConfig.VerbosityLevel >= config.VerbosityNormal {
			fmt.Println("⚠️  No ANTHROPIC_API_KEY found. Running in offline mode (limited functionality).")
			fmt.Println("   Set your API key: export ANTHROPIC_API_KEY='your-key-here'")
		}
	} else {
		if analysisConfig.VerbosityLevel >= config.VerbosityNormal {
			fmt.Printf("✅ Claude API configured (key: %s...%s)\n", apiKey[:8], apiKey[len(apiKey)-4:])
		}
	}

	switch mode {
	case "interactive":
		runInteractiveMode(apiKey, projectPath, analysisConfig)
	case "query":
		runSingleQuery(apiKey, query, projectPath, analysisConfig)
	case "help":
		showHelp()
	default:
		showHelp()
	}
}

func parseArgs() (string, string, string, *config.AnalysisConfig) {
	if len(os.Args) < 2 {
		return "help", "", ".", &config.AnalysisConfig{
			VerbosityLevel:      config.VerbosityNormal,
			ShowPrompts:         false,
			ConfidenceThreshold: config.DefaultConfidenceThreshold,
			MaxFilesToAnalyze:   config.MaxFilesToAnalyze,
			MaxLinesPerFile:     config.MaxLinesPerFile,
		}
	}

	// Default values
	projectPath := "."
	var query string
	mode := "interactive" // Default to interactive mode

	// Default analysis configuration
	analysisConfig := &config.AnalysisConfig{
		VerbosityLevel:      config.VerbosityNormal,
		ShowPrompts:         false,
		ConfidenceThreshold: config.DefaultConfidenceThreshold,
		MaxFilesToAnalyze:   config.MaxFilesToAnalyze,
		MaxLinesPerFile:     config.MaxLinesPerFile,
	}

	// Parse arguments
	for i, arg := range os.Args[1:] {
		switch arg {
		case "--ask", "-q":
			mode = "query"
			if i+2 < len(os.Args) {
				query = os.Args[i+2]
			}
		case "--path", "-p":
			if i+2 < len(os.Args) {
				projectPath = os.Args[i+2]
			}
		case "--interactive", "-i":
			mode = "interactive"
		case "--show-prompts", "--debug-prompts":
			analysisConfig.ShowPrompts = true
			if analysisConfig.VerbosityLevel >= config.VerbosityNormal {
				fmt.Println("🔍 Debug mode: Will show detailed prompt information")
			}
		case "--quiet", "-quiet":
			analysisConfig.VerbosityLevel = config.VerbosityQuiet
		case "--verbose", "-verbose":
			analysisConfig.VerbosityLevel = config.VerbosityVerbose
		case "--simple":
			complexity := config.ComplexitySimple
			analysisConfig.ForceComplexity = &complexity
		case "--complex":
			complexity := config.ComplexityComplex
			analysisConfig.ForceComplexity = &complexity
		case "--help", "-h":
			mode = "help"
		default:
			// If it's not a flag and no query is set, treat it as project path
			if !strings.HasPrefix(arg, "-") && query == "" && mode == "interactive" {
				projectPath = arg
			}
		}
	}

	return mode, query, projectPath, analysisConfig
}

func runSingleQuery(apiKey, query, projectPath string, analysisConfig *config.AnalysisConfig) {
	if strings.TrimSpace(query) == "" {
		err := errors.NewValidationError(errors.ErrCodeEmptyQuery, "--ask parameter is required for query mode")
		fmt.Printf("❌ Error: %v\n", err)
		os.Exit(1)
	}

	if analysisConfig.VerbosityLevel >= config.VerbosityNormal {
		fmt.Printf("\n🎯 Single Query Mode: %s\n", query)
		fmt.Printf("📁 Project: %s\n", filepath.Clean(projectPath))
	}

	// Create analyzer with configuration
	analyzer := analysis.NewCursorStyleAnalyzerWithConfig(apiKey, analysisConfig)

	// Run analysis
	result, err := analyzer.Ask(query, projectPath)
	if err != nil {
		if analysisConfig.VerbosityLevel >= config.VerbosityQuiet {
			fmt.Printf("❌ Analysis failed: %v\n", err)
		}
		os.Exit(1)
	}

	// Output results based on verbosity level
	switch analysisConfig.VerbosityLevel {
	case config.VerbosityQuiet:
		fmt.Println(result)
	case config.VerbosityNormal:
		fmt.Println("\n" + strings.Repeat("=", 80))
		fmt.Println("📄 ANALYSIS RESULT:")
		fmt.Println(strings.Repeat("=", 80))
		fmt.Println(result)
	case config.VerbosityVerbose:
		fmt.Println("\n" + strings.Repeat("=", 80))
		fmt.Println("📄 COMPREHENSIVE ANALYSIS:")
		fmt.Println(strings.Repeat("=", 80))
		fmt.Println(result)
	}
}

func runInteractiveMode(apiKey, projectPath string, analysisConfig *config.AnalysisConfig) {
	if analysisConfig.VerbosityLevel >= config.VerbosityNormal {
		fmt.Println("\n🚀 Starting Interactive Analysis Mode...")
		fmt.Printf("📁 Project: %s\n", filepath.Clean(projectPath))
		fmt.Println("\n💬 Interactive Mode (type 'exit' to quit, 'help' for commands)")
		fmt.Println("Ask comprehensive questions about your codebase:")
	}

	// Create analyzer with configuration
	analyzer := analysis.NewCursorStyleAnalyzerWithConfig(apiKey, analysisConfig)

	// Simple interactive loop - just ask questions and get comprehensive answers
	for {
		fmt.Print("\n❓ Query: ")

		var query string
		if _, err := fmt.Scanln(&query); err != nil {
			// Handle input error gracefully - continue with empty query
			query = ""
		}

		if query == "" {
			continue
		}

		if query == "exit" || query == "quit" {
			if analysisConfig.VerbosityLevel >= config.VerbosityNormal {
				fmt.Println("👋 Goodbye!")
			}
			break
		}

		if query == "help" {
			showInteractiveHelp()
			continue
		}

		// Process the query
		if analysisConfig.VerbosityLevel >= config.VerbosityNormal {
			fmt.Println("🤔 Analyzing...")
		}

		result, err := analyzer.Ask(query, projectPath)
		if err != nil {
			fmt.Printf("❌ Error: %v\n", err)
			continue
		}

		// Display result based on verbosity level
		switch analysisConfig.VerbosityLevel {
		case config.VerbosityQuiet:
			fmt.Println(result)
		default:
			fmt.Println("\n" + strings.Repeat("─", 80))
			fmt.Println("📄 ANALYSIS RESULT:")
			fmt.Println(strings.Repeat("─", 80))
			fmt.Println(result)
			fmt.Println(strings.Repeat("─", 80))
		}
	}
}

func showHelp() {
	fmt.Println("\n🆘 CODESEARCH - Advanced Code Analysis Tool")
	fmt.Println("==========================================")
	fmt.Println()
	fmt.Println("OPTIONS:")
	fmt.Println("  --quiet         Minimal output (results only)")
	fmt.Println("  --verbose       Detailed progress information")
	fmt.Println("  --simple        Force simple analysis (faster)")
	fmt.Println("  --complex       Force deep multi-pass analysis")
	fmt.Println("  --show-prompts  Show detailed prompt information")
	fmt.Println("  --path PATH     Specify project path")
	fmt.Println()
	fmt.Println("EXAMPLES:")
	fmt.Println("  go run main.go --ask \"Is this 2D or 3D?\"")
	fmt.Println("  go run main.go --ask \"How does auth work?\" --quiet")
	fmt.Println("  go run main.go --ask \"Analyze architecture\" --verbose")
	fmt.Println("  go run main.go --ask \"Find bugs\" --simple --path /project")
	fmt.Println()
	fmt.Println("ENVIRONMENT:")
	fmt.Println("  export ANTHROPIC_API_KEY='your-key-here'")
	fmt.Println("  Get your key: https://console.anthropic.com/")
}

func showInteractiveHelp() {
	fmt.Println("\n🆘 Interactive Commands:")
	fmt.Println("   help - Show this help")
	fmt.Println("   exit - Exit the program")
	fmt.Println()
	fmt.Println("💡 Example queries:")
	fmt.Println("   • How does authentication work?")
	fmt.Println("   • Explain the registration service")
	fmt.Println("   • What are the main components?")
	fmt.Println("   • Show me error handling patterns")
	fmt.Println("   • Analyze the architecture")
}