package main

import (
	"flag"
	"fmt"
	"log"
	"os"

	tea "github.com/charmbracelet/bubbletea"
	"github.com/orca/orca/internal/config"
	"github.com/orca/orca/internal/tui"
	"github.com/orca/orca/internal/websocket"
	"github.com/orca/orca/pkg/kernel"
	"github.com/orca/orca/pkg/session"
)

func main() {
	webMode := flag.Bool("web", false, "Run in web mode on port 8081")
	memoryCmd := flag.Bool("memory", false, "Memory management commands (list, stats, clean)")
	flag.Parse()

	cfg, err := config.LoadConfig()
	if err != nil {
		log.Fatalf("Failed to load config: %v", err)
	}

	if *memoryCmd {
		handleMemoryCommand(flag.Args())
		return
	}

	k := kernel.NewWithConfig(cfg)
	if err := k.Start(); err != nil {
		log.Fatalf("Failed to start kernel: %v", err)
	}

	if err := k.InitPlugins(); err != nil {
		log.Printf("Warning: failed to load skills: %v", err)
	}

	if *webMode {
		server := websocket.NewServer(k, 8081)
		fmt.Println("Starting web server on http://localhost:8081")
		if err := server.Start(); err != nil {
			log.Fatalf("Failed to start web server: %v", err)
		}
	} else {
		m := tui.NewModel(k)
		p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithMouseCellMotion())

		if _, err := p.Run(); err != nil {
			fmt.Fprintf(os.Stderr, "Error running TUI: %v\n", err)
			os.Exit(1)
		}
	}

	if err := k.Stop(); err != nil {
		log.Printf("Warning: error stopping kernel: %v", err)
	}
}

func handleMemoryCommand(args []string) {
	if len(args) == 0 {
		fmt.Println("Usage: orca -memory <command>")
		fmt.Println("Commands:")
		fmt.Println("  list    List all memories")
		fmt.Println("  stats   Show memory statistics")
		fmt.Println("  clean   Clean archived memories")
		return
	}

	cfg, err := config.LoadConfig()
	if err != nil {
		log.Fatalf("Failed to load config: %v", err)
	}

	mm, err := session.NewMemoryManager(session.MemoryConfig{
		DBPath: cfg.Session.StorageDir + "/memory.db",
	})
	if err != nil {
		log.Fatalf("Failed to create memory manager: %v", err)
	}
	defer mm.Close()

	switch args[0] {
	case "list":
		memories, err := mm.GetLongTermMemory("")
		if err != nil {
			log.Fatalf("Failed to list memories: %v", err)
		}
		fmt.Printf("Total memories: %d\n", len(memories))
		for _, m := range memories {
			fmt.Printf("  [%d] %s (weight=%.2f)\n", m.ID, m.Content, m.Weight)
		}
	case "stats":
		size, hits, misses := mm.CacheStats()
		fmt.Printf("Cache size: %d\n", size)
		fmt.Printf("Cache hits: %d\n", hits)
		fmt.Printf("Cache misses: %d\n", misses)
	case "clean":
		count, err := mm.ArchiveLowWeightMemories(0.3)
		if err != nil {
			log.Fatalf("Failed to clean memories: %v", err)
		}
		fmt.Printf("Archived %d memories\n", count)
	default:
		fmt.Printf("Unknown command: %s\n", args[0])
	}
}