package main

import (
	"bytes"
	"context"
	"errors"
	"flag"
	"fmt"
	"io"
	"io/fs"
	"log/slog"
	"math"
	"net/http"
	"os"
	"os/exec"
	"os/signal"
	"path/filepath"
	"runtime"
	"sort"
	"strconv"
	"strings"
	syncpkg "sync"
	"syscall"
	"time"

	qfassets "git.mchus.pro/mchus/quoteforge"
	"git.mchus.pro/mchus/quoteforge/internal/appmeta"
	"git.mchus.pro/mchus/quoteforge/internal/appstate"
	"git.mchus.pro/mchus/quoteforge/internal/config"
	"git.mchus.pro/mchus/quoteforge/internal/db"
	"git.mchus.pro/mchus/quoteforge/internal/handlers"
	"git.mchus.pro/mchus/quoteforge/internal/localdb"
	"git.mchus.pro/mchus/quoteforge/internal/middleware"
	"git.mchus.pro/mchus/quoteforge/internal/models"
	"git.mchus.pro/mchus/quoteforge/internal/services"
	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
	"github.com/gin-gonic/gin"
	"gopkg.in/yaml.v3"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

// Version is set via ldflags during build
var Version = "dev"

const backgroundSyncInterval = 5 * time.Minute
const onDemandPullCooldown = 30 * time.Second
const startupConsoleWarning = "Не закрывайте консоль иначе приложение не будет работать"

func main() {
	showStartupConsoleWarning()

	configPath := flag.String("config", "", "path to config file (default: user state dir or QFS_CONFIG_PATH)")
	localDBPath := flag.String("localdb", "", "path to local SQLite database (default: user state dir or QFS_DB_PATH)")
	resetLocalDB := flag.Bool("reset-localdb", false, "reset local SQLite data on startup (keeps connection settings)")
	migrate := flag.Bool("migrate", false, "run database migrations")
	version := flag.Bool("version", false, "show version information")
	flag.Parse()

	// Show version if requested
	if *version {
		fmt.Printf("qfs version %s\n", Version)
		os.Exit(0)
	}

	exePath, _ := os.Executable()
	slog.Info("starting qfs", "version", Version, "executable", exePath)
	appmeta.SetVersion(Version)

	resolvedLocalDBPath, err := appstate.ResolveDBPath(*localDBPath)
	if err != nil {
		slog.Error("failed to resolve local database path", "error", err)
		os.Exit(1)
	}

	resolvedConfigPath, err := appstate.ResolveConfigPathNearDB(*configPath, resolvedLocalDBPath)
	if err != nil {
		slog.Error("failed to resolve config path", "error", err)
		os.Exit(1)
	}

	// Migrate legacy project-local config path to the user state directory when using defaults.
	if *configPath == "" && os.Getenv("QFS_CONFIG_PATH") == "" {
		migratedFrom, migrateErr := appstate.MigrateLegacyFile(resolvedConfigPath, []string{"config.yaml"})
		if migrateErr != nil {
			slog.Warn("failed to migrate legacy config file", "error", migrateErr)
		} else if migratedFrom != "" {
			slog.Info("migrated legacy config file", "from", migratedFrom, "to", resolvedConfigPath)
		}
	}

	// Migrate legacy project-local DB path to the user state directory when using defaults.
	if *localDBPath == "" && os.Getenv("QFS_DB_PATH") == "" {
		legacyPaths := []string{
			filepath.Join("data", "settings.db"),
			filepath.Join("data", "qfs.db"),
		}
		migratedFrom, migrateErr := appstate.MigrateLegacyDB(resolvedLocalDBPath, legacyPaths)
		if migrateErr != nil {
			slog.Warn("failed to migrate legacy local database", "error", migrateErr)
		} else if migratedFrom != "" {
			slog.Info("migrated legacy local database", "from", migratedFrom, "to", resolvedLocalDBPath)
		}
	}

	if shouldResetLocalDB(*resetLocalDB) {
		if err := localdb.ResetData(resolvedLocalDBPath); err != nil {
			slog.Error("failed to reset local database", "error", err)
			os.Exit(1)
		}
	}

	// Initialize local SQLite database (always used)
	local, err := localdb.New(resolvedLocalDBPath)
	if err != nil {
		slog.Error("failed to initialize local database", "error", err)
		os.Exit(1)
	}

	// Check if running in setup mode (no connection settings)
	if !local.HasSettings() {
		slog.Info("no database settings found, starting setup mode")
		runSetupMode(local)
		return
	}

	// Load config for server settings (optional)
	if err := ensureDefaultConfigFile(resolvedConfigPath); err != nil {
		slog.Error("failed to ensure default config file", "path", resolvedConfigPath, "error", err)
		os.Exit(1)
	}
	cfg, err := config.Load(resolvedConfigPath)
	if err != nil {
		if errors.Is(err, fs.ErrNotExist) {
			// Use defaults if config file doesn't exist
			slog.Info("config file not found, using defaults", "path", resolvedConfigPath)
			cfg = &config.Config{}
		} else {
			slog.Error("failed to load config", "path", resolvedConfigPath, "error", err)
			os.Exit(1)
		}
	}
	setConfigDefaults(cfg)
	if err := migrateConfigFileToRuntimeShape(resolvedConfigPath, cfg); err != nil {
		slog.Error("failed to migrate config file format", "path", resolvedConfigPath, "error", err)
		os.Exit(1)
	}
	slog.Info("resolved runtime files", "config_path", resolvedConfigPath, "localdb_path", resolvedLocalDBPath)

	setupLogger(cfg.Logging)

	// Create connection manager. Runtime stays local-first; MariaDB is used on demand by sync/setup only.
	connMgr := db.NewConnectionManager(local)

	dbUser := local.GetDBUser()

	slog.Info("starting QuoteForge server",
		"version", Version,
		"host", cfg.Server.Host,
		"port", cfg.Server.Port,
		"db_user", dbUser,
		"online", false,
	)

	if *migrate {
		mariaDB, err := connMgr.GetDB()
		if err != nil {
			slog.Error("cannot run migrations: database not available", "error", err)
			os.Exit(1)
		}
		if mariaDB == nil {
			slog.Error("cannot run migrations: database not available")
			os.Exit(1)
		}
		slog.Info("running database migrations...")
		if err := models.Migrate(mariaDB); err != nil {
			slog.Error("migration failed", "error", err)
			os.Exit(1)
		}
		if err := models.SeedCategories(mariaDB); err != nil {
			slog.Error("seeding categories failed", "error", err)
			os.Exit(1)
		}
		slog.Info("migrations completed")
	}

	gin.SetMode(cfg.Server.Mode)
	restartSig := make(chan struct{}, 1)

	router, syncService, err := setupRouter(cfg, local, connMgr, dbUser, restartSig)
	if err != nil {
		slog.Error("failed to setup router", "error", err)
		os.Exit(1)
	}

	if readiness, readinessErr := syncService.GetReadiness(); readinessErr != nil {
		slog.Warn("sync readiness check failed on startup", "error", readinessErr)
	} else if readiness != nil && readiness.Blocked {
		slog.Warn("sync readiness blocked on startup",
			"reason_code", readiness.ReasonCode,
			"reason_text", readiness.ReasonText,
		)
	}

	// Start background sync worker (will auto-skip when offline)
	workerCtx, workerCancel := context.WithCancel(context.Background())
	defer workerCancel()

	syncWorker := sync.NewWorker(syncService, connMgr, backgroundSyncInterval)
	go syncWorker.Start(workerCtx)

	backupCtx, backupCancel := context.WithCancel(context.Background())
	defer backupCancel()
	go startBackupScheduler(backupCtx, cfg, resolvedLocalDBPath, resolvedConfigPath)

	srv := &http.Server{
		Addr:         cfg.Address(),
		Handler:      router,
		ReadTimeout:  cfg.Server.ReadTimeout,
		WriteTimeout: cfg.Server.WriteTimeout,
	}

	go func() {
		slog.Info("server listening", "address", cfg.Address())
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			slog.Error("server error", "error", err)
			os.Exit(1)
		}
	}()

	// Automatically open browser after server starts (with a small delay)
	go func() {
		time.Sleep(1 * time.Second)
		// Always use localhost for browser, even if server binds to 0.0.0.0
		browserURL := fmt.Sprintf("http://127.0.0.1:%d", cfg.Server.Port)
		slog.Info("Opening browser to", "url", browserURL)
		err := openBrowser(browserURL)
		if err != nil {
			slog.Warn("Failed to open browser", "error", err)
		}
	}()

	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

	shouldRestart := false
	select {
	case <-quit:
		slog.Info("shutting down server...")
	case <-restartSig:
		shouldRestart = true
		slog.Info("restarting application after connection settings update...")
	}

	// Stop background sync worker first
	syncWorker.Stop()
	workerCancel()
	backupCancel()

	// Then shutdown HTTP server
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	if err := srv.Shutdown(ctx); err != nil {
		slog.Error("server forced to shutdown", "error", err)
	}

	slog.Info("server stopped")

	if shouldRestart {
		restartProcess()
	}
}

func showStartupConsoleWarning() {
	// Visible in console output.
	fmt.Println(startupConsoleWarning)
	// Keep the warning always visible in the console window title when supported.
	fmt.Printf("\033]0;%s\007", startupConsoleWarning)
}

func shouldResetLocalDB(flagValue bool) bool {
	if flagValue {
		return true
	}
	value := strings.TrimSpace(os.Getenv("QFS_RESET_LOCAL_DB"))
	if value == "" {
		return false
	}
	switch strings.ToLower(value) {
	case "1", "true", "yes", "y":
		return true
	default:
		return false
	}
}

func derefString(value *string) string {
	if value == nil {
		return ""
	}
	return *value
}

func setConfigDefaults(cfg *config.Config) {
	if cfg.Server.Host == "" {
		cfg.Server.Host = "127.0.0.1"
	}
	if cfg.Server.Port == 0 {
		cfg.Server.Port = 8080
	}
	if cfg.Server.Mode == "" {
		cfg.Server.Mode = "release"
	}
	if cfg.Server.ReadTimeout == 0 {
		cfg.Server.ReadTimeout = 30 * time.Second
	}
	if cfg.Server.WriteTimeout == 0 {
		cfg.Server.WriteTimeout = 30 * time.Second
	}
	if cfg.Pricing.DefaultMethod == "" {
		cfg.Pricing.DefaultMethod = "weighted_median"
	}
	if cfg.Pricing.DefaultPeriodDays == 0 {
		cfg.Pricing.DefaultPeriodDays = 90
	}
	if cfg.Pricing.FreshnessGreenDays == 0 {
		cfg.Pricing.FreshnessGreenDays = 30
	}
	if cfg.Pricing.FreshnessYellowDays == 0 {
		cfg.Pricing.FreshnessYellowDays = 60
	}
	if cfg.Pricing.FreshnessRedDays == 0 {
		cfg.Pricing.FreshnessRedDays = 90
	}
	if cfg.Pricing.MinQuotesForMedian == 0 {
		cfg.Pricing.MinQuotesForMedian = 3
	}
	if cfg.Backup.Time == "" {
		cfg.Backup.Time = "00:00"
	}
}

func ensureDefaultConfigFile(configPath string) error {
	if strings.TrimSpace(configPath) == "" {
		return fmt.Errorf("config path is empty")
	}
	if _, err := os.Stat(configPath); err == nil {
		return nil
	} else if !errors.Is(err, os.ErrNotExist) {
		return err
	}

	if err := os.MkdirAll(filepath.Dir(configPath), 0755); err != nil {
		return err
	}

	const defaultConfigYAML = `server:
  host: "127.0.0.1"
  port: 8080
  mode: "release"
  read_timeout: 30s
  write_timeout: 30s

backup:
  time: "00:00"

logging:
  level: "info"
  format: "json"
  output: "stdout"
`
	if err := os.WriteFile(configPath, []byte(defaultConfigYAML), 0644); err != nil {
		return err
	}
	slog.Info("created default config file", "path", configPath)
	return nil
}

type runtimeServerConfig struct {
	Host         string        `yaml:"host"`
	Port         int           `yaml:"port"`
	Mode         string        `yaml:"mode"`
	ReadTimeout  time.Duration `yaml:"read_timeout"`
	WriteTimeout time.Duration `yaml:"write_timeout"`
}

type runtimeLoggingConfig struct {
	Level  string `yaml:"level"`
	Format string `yaml:"format"`
	Output string `yaml:"output"`
}

type runtimeBackupConfig struct {
	Time string `yaml:"time"`
}

type runtimeConfigFile struct {
	Server  runtimeServerConfig  `yaml:"server"`
	Logging runtimeLoggingConfig `yaml:"logging"`
	Backup  runtimeBackupConfig  `yaml:"backup"`
}

// migrateConfigFileToRuntimeShape rewrites config.yaml in a minimal runtime format.
// Deprecated sections from legacy configs are intentionally dropped.
func migrateConfigFileToRuntimeShape(configPath string, cfg *config.Config) error {
	if cfg == nil {
		return fmt.Errorf("config is nil")
	}

	runtimeCfg := runtimeConfigFile{
		Server: runtimeServerConfig{
			Host:         cfg.Server.Host,
			Port:         cfg.Server.Port,
			Mode:         cfg.Server.Mode,
			ReadTimeout:  cfg.Server.ReadTimeout,
			WriteTimeout: cfg.Server.WriteTimeout,
		},
		Logging: runtimeLoggingConfig{
			Level:  cfg.Logging.Level,
			Format: cfg.Logging.Format,
			Output: cfg.Logging.Output,
		},
		Backup: runtimeBackupConfig{
			Time: cfg.Backup.Time,
		},
	}

	rendered, err := yaml.Marshal(&runtimeCfg)
	if err != nil {
		return fmt.Errorf("marshal runtime config: %w", err)
	}

	current, err := os.ReadFile(configPath)
	if err == nil && bytes.Equal(bytes.TrimSpace(current), bytes.TrimSpace(rendered)) {
		return nil
	}
	if err := os.WriteFile(configPath, rendered, 0644); err != nil {
		return fmt.Errorf("write runtime config: %w", err)
	}
	slog.Info("migrated config.yaml to runtime format", "path", configPath)
	return nil
}

func startBackupScheduler(ctx context.Context, cfg *config.Config, dbPath, configPath string) {
	if cfg == nil {
		return
	}

	hour, minute, err := parseBackupTime(cfg.Backup.Time)
	if err != nil {
		slog.Warn("invalid backup time; using 00:00", "value", cfg.Backup.Time, "error", err)
		hour = 0
		minute = 0
	}

	if created, backupErr := appstate.EnsureRotatingLocalBackup(dbPath, configPath); backupErr != nil {
		slog.Error("local backup failed", "error", backupErr)
	} else if len(created) > 0 {
		for _, path := range created {
			slog.Info("local backup completed", "archive", path)
		}
	}

	for {
		next := nextBackupTime(time.Now(), hour, minute)
		timer := time.NewTimer(time.Until(next))

		select {
		case <-ctx.Done():
			timer.Stop()
			return
		case <-timer.C:
			start := time.Now()
			created, backupErr := appstate.EnsureRotatingLocalBackup(dbPath, configPath)
			duration := time.Since(start)
			if backupErr != nil {
				slog.Error("local backup failed", "error", backupErr, "duration", duration)
			} else {
				for _, path := range created {
					slog.Info("local backup completed", "archive", path, "duration", duration)
				}
			}
		}
	}
}

func parseBackupTime(value string) (int, int, error) {
	if strings.TrimSpace(value) == "" {
		return 0, 0, fmt.Errorf("empty backup time")
	}
	parsed, err := time.Parse("15:04", value)
	if err != nil {
		return 0, 0, err
	}
	return parsed.Hour(), parsed.Minute(), nil
}

func nextBackupTime(now time.Time, hour, minute int) time.Time {
	location := now.Location()
	target := time.Date(now.Year(), now.Month(), now.Day(), hour, minute, 0, 0, location)
	if !now.Before(target) {
		target = target.Add(24 * time.Hour)
	}
	return target
}

// runSetupMode starts a minimal server that only serves the setup page
func runSetupMode(local *localdb.LocalDB) {
	restartSig := make(chan struct{}, 1)

	// In setup mode, we don't have a connection manager yet (will restart after setup)
	templatesPath := filepath.Join("web", "templates")
	setupHandler, err := handlers.NewSetupHandler(local, nil, templatesPath, restartSig)
	if err != nil {
		slog.Error("failed to create setup handler", "error", err)
		os.Exit(1)
	}

	gin.SetMode(gin.ReleaseMode)
	router := gin.New()
	router.Use(gin.Recovery())

	if staticFS, err := qfassets.StaticFS(); err == nil {
		router.StaticFS("/static", http.FS(staticFS))
	} else {
		slog.Error("failed to load embedded static assets", "error", err)
		os.Exit(1)
	}

	// Setup routes only
	router.GET("/", func(c *gin.Context) {
		c.Redirect(http.StatusFound, "/setup")
	})
	router.GET("/setup", setupHandler.ShowSetup)
	router.POST("/setup", setupHandler.SaveConnection)
	router.POST("/setup/test", setupHandler.TestConnection)
	router.GET("/setup/status", setupHandler.GetStatus)

	// Health check
	router.GET("/health", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"status": "setup_required",
			"time":   time.Now().UTC().Format(time.RFC3339),
		})
	})

	addr := "127.0.0.1:8080"
	slog.Info("starting setup mode server", "address", addr, "version", Version)

	srv := &http.Server{
		Addr:    addr,
		Handler: router,
	}

	go func() {
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			slog.Error("server error", "error", err)
			os.Exit(1)
		}
	}()

	// Open browser to setup page
	go func() {
		time.Sleep(1 * time.Second)
		browserURL := "http://127.0.0.1:8080/setup"
		slog.Info("Opening browser to setup page", "url", browserURL)
		err := openBrowser(browserURL)
		if err != nil {
			slog.Warn("Failed to open browser", "error", err)
		}
	}()

	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

	select {
	case <-quit:
		slog.Info("setup mode server stopped")
	case <-restartSig:
		slog.Info("restarting application with saved settings...")

		// Graceful shutdown
		ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
		defer cancel()
		srv.Shutdown(ctx)

		// Restart process with same arguments
		restartProcess()
	}
}

func setupLogger(cfg config.LoggingConfig) {
	var level slog.Level
	switch cfg.Level {
	case "debug":
		level = slog.LevelDebug
	case "warn":
		level = slog.LevelWarn
	case "error":
		level = slog.LevelError
	default:
		level = slog.LevelInfo
	}

	opts := &slog.HandlerOptions{Level: level}

	var handler slog.Handler
	if cfg.Format == "json" {
		handler = slog.NewJSONHandler(os.Stdout, opts)
	} else {
		handler = slog.NewTextHandler(os.Stdout, opts)
	}

	slog.SetDefault(slog.New(handler))
}

func setupDatabaseFromDSN(dsn string) (*gorm.DB, error) {
	gormLogger := logger.Default.LogMode(logger.Silent)

	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
		Logger: gormLogger,
	})
	if err != nil {
		return nil, err
	}

	sqlDB, err := db.DB()
	if err != nil {
		return nil, err
	}

	sqlDB.SetMaxOpenConns(25)
	sqlDB.SetMaxIdleConns(5)
	sqlDB.SetConnMaxLifetime(5 * time.Minute)

	return db, nil
}

func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.ConnectionManager, dbUsername string, restartSig chan struct{}) (*gin.Engine, *sync.Service, error) {
	var syncService *sync.Service
	var projectService *services.ProjectService

	syncService = sync.NewService(connMgr, local)
	componentService := services.NewComponentService(nil, nil, nil)
	quoteService := services.NewQuoteService(nil, nil, nil, local, nil)
	exportService := services.NewExportService(cfg.Export, nil, local)

	// isOnline function for local-first architecture
	isOnline := func() bool {
		return connMgr.IsOnline()
	}

	// Local-first configuration service (replaces old ConfigurationService)
	projectService = services.NewProjectService(local)
	configService := services.NewLocalConfigurationService(local, syncService, quoteService, isOnline)

	// Data hygiene: remove empty nameless projects and ensure every configuration is attached to a project.
	if removed, err := local.ConsolidateSystemProjects(); err == nil && removed > 0 {
		slog.Info("consolidated duplicate local system projects", "removed", removed)
	}
	if removed, err := local.PurgeEmptyNamelessProjects(); err == nil && removed > 0 {
		slog.Info("purged empty nameless local projects", "removed", removed)
	}
	if err := local.BackfillConfigurationProjects(dbUsername); err != nil {
		slog.Warn("failed to backfill local configuration projects", "error", err)
	}
	type pullState struct {
		mu          syncpkg.Mutex
		running     bool
		lastStarted time.Time
	}
	triggerPull := func(label string, state *pullState, pullFn func() error) {
		state.mu.Lock()
		if state.running {
			state.mu.Unlock()
			return
		}
		if !state.lastStarted.IsZero() && time.Since(state.lastStarted) < onDemandPullCooldown {
			state.mu.Unlock()
			return
		}
		state.running = true
		state.lastStarted = time.Now()
		state.mu.Unlock()

		go func() {
			defer func() {
				state.mu.Lock()
				state.running = false
				state.mu.Unlock()
			}()
			if err := pullFn(); err != nil {
				slog.Warn("on-demand pull failed", "scope", label, "error", err)
			}
		}()
	}

	var projectsPullState pullState
	var configsPullState pullState

	syncProjectsFromServer := func() error {
		if !connMgr.IsOnline() {
			return nil
		}
		if readiness, err := syncService.EnsureReadinessForSync(); err != nil {
			slog.Warn("skipping project pull: sync readiness blocked",
				"error", err,
				"reason_code", readiness.ReasonCode,
				"reason_text", readiness.ReasonText,
			)
			return nil
		}
		if _, err := syncService.ImportProjectsToLocal(); err != nil && !errors.Is(err, sync.ErrOffline) {
			return err
		}
		return nil
	}

	syncConfigurationsFromServer := func() error {
		if !connMgr.IsOnline() {
			return nil
		}
		if readiness, err := syncService.EnsureReadinessForSync(); err != nil {
			slog.Warn("skipping configuration pull: sync readiness blocked",
				"error", err,
				"reason_code", readiness.ReasonCode,
				"reason_text", readiness.ReasonText,
			)
			return nil
		}
		_, err := configService.ImportFromServer()
		if err != nil && !errors.Is(err, sync.ErrOffline) {
			return err
		}
		return nil
	}

	// Use filepath.Join for cross-platform path compatibility
	templatesPath := filepath.Join("web", "templates")

	// Handlers
	componentHandler := handlers.NewComponentHandler(componentService, local)
	quoteHandler := handlers.NewQuoteHandler(quoteService)
	exportHandler := handlers.NewExportHandler(exportService, configService, projectService, dbUsername)
	pricelistHandler := handlers.NewPricelistHandler(local)
	vendorSpecHandler := handlers.NewVendorSpecHandler(local)
	partnumberBooksHandler := handlers.NewPartnumberBooksHandler(local)
	syncHandler, err := handlers.NewSyncHandler(local, syncService, connMgr, templatesPath, backgroundSyncInterval)
	if err != nil {
		return nil, nil, fmt.Errorf("creating sync handler: %w", err)
	}

	// Setup handler (for reconfiguration)
	setupHandler, err := handlers.NewSetupHandler(local, connMgr, templatesPath, restartSig)
	if err != nil {
		return nil, nil, fmt.Errorf("creating setup handler: %w", err)
	}

	// Web handler (templates)
	webHandler, err := handlers.NewWebHandler(templatesPath, local)
	if err != nil {
		return nil, nil, err
	}

	// Router
	router := gin.New()
	router.Use(gin.Recovery())
	router.Use(requestLogger())
	router.Use(middleware.CORS())
	router.Use(middleware.OfflineDetector(connMgr, local))

	// Static files (use filepath.Join for Windows compatibility)
	if staticFS, err := qfassets.StaticFS(); err == nil {
		router.StaticFS("/static", http.FS(staticFS))
	} else {
		return nil, nil, fmt.Errorf("load embedded static assets: %w", err)
	}

	// Health check
	router.GET("/health", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"status": "ok",
			"time":   time.Now().UTC().Format(time.RFC3339),
		})
	})

	// Restart endpoint (for development purposes)
	router.POST("/api/restart", func(c *gin.Context) {
		// This will cause the server to restart by exiting
		// The restartProcess function will be called to restart the process
		slog.Info("Restart requested via API")
		go func() {
			time.Sleep(100 * time.Millisecond)
			restartProcess()
		}()
		c.JSON(http.StatusOK, gin.H{"message": "restarting..."})
	})

	// DB status endpoint
	router.GET("/api/db-status", func(c *gin.Context) {
		var lotCount, lotLogCount, metadataCount int64
		var dbOK bool
		var dbError string
		includeCounts := c.Query("include_counts") == "true"

		// Fast status path: do not execute heavy COUNT queries unless requested.
		status := connMgr.GetStatus()
		dbOK = status.IsConnected
		if !status.IsConnected {
			dbError = "Database not connected (offline mode)"
			if status.LastError != "" {
				dbError = status.LastError
			}
		}

		// Runtime diagnostics stay local-only. Server table counts are intentionally unavailable here.
		if !includeCounts || !status.IsConnected {
			lotCount = 0
			lotLogCount = 0
			metadataCount = 0
		}

		c.JSON(http.StatusOK, gin.H{
			"connected":      dbOK,
			"error":          dbError,
			"lot_count":      lotCount,
			"lot_log_count":  lotLogCount,
			"metadata_count": metadataCount,
			"db_user":        local.GetDBUser(),
		})
	})

	// Current user info (local DB username)
	router.GET("/api/current-user", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"username": local.GetDBUser(),
		})
	})

	// Setup routes (for reconfiguration)
	router.GET("/setup", setupHandler.ShowSetup)
	router.POST("/setup", setupHandler.SaveConnection)
	router.POST("/setup/test", setupHandler.TestConnection)
	router.GET("/setup/status", setupHandler.GetStatus)

	// Web pages
	router.GET("/", webHandler.Index)
	router.GET("/configs", webHandler.Configs)
	router.GET("/configurator", webHandler.Configurator)
	router.GET("/projects", webHandler.Projects)
	router.GET("/projects/:uuid", webHandler.ProjectDetail)
	router.GET("/configs/:uuid/revisions", webHandler.ConfigRevisions)
	router.GET("/pricelists", webHandler.Pricelists)
	router.GET("/pricelists/:id", webHandler.PricelistDetail)
	router.GET("/partnumber-books", webHandler.PartnumberBooks)

	// htmx partials
	partials := router.Group("/partials")
	{
		partials.GET("/components", webHandler.ComponentsPartial)
		partials.GET("/sync-status", syncHandler.SyncStatusPartial)
	}

	// API routes
	api := router.Group("/api")
	{
		api.GET("/ping", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"message": "pong"})
		})

		// Components (public read)
		components := api.Group("/components")
		{
			components.GET("", componentHandler.List)
			components.GET("/:lot_name", componentHandler.Get)
		}

		// Categories (public)
		api.GET("/categories", componentHandler.GetCategories)

		// Quote (public)
		quote := api.Group("/quote")
		{
			quote.POST("/validate", quoteHandler.Validate)
			quote.POST("/calculate", quoteHandler.Calculate)
			quote.POST("/price-levels", quoteHandler.PriceLevels)
		}

		// Export (public)
		export := api.Group("/export")
		{
			export.POST("/csv", exportHandler.ExportCSV)
		}

		// Pricelists (public - RBAC disabled in Phase 1-3)
		pricelists := api.Group("/pricelists")
		{
			pricelists.GET("", pricelistHandler.List)
			pricelists.GET("/latest", pricelistHandler.GetLatest)
			pricelists.GET("/:id", pricelistHandler.Get)
			pricelists.GET("/:id/items", pricelistHandler.GetItems)
			pricelists.GET("/:id/lots", pricelistHandler.GetLotNames)
		}

		// Partnumber books (read-only)
		pnBooks := api.Group("/partnumber-books")
		{
			pnBooks.GET("", partnumberBooksHandler.List)
			pnBooks.GET("/:id", partnumberBooksHandler.GetItems)
		}

		// Configurations (public - RBAC disabled)
		configs := api.Group("/configs")
		{
			configs.GET("", func(c *gin.Context) {
				triggerPull("configs", &configsPullState, syncConfigurationsFromServer)

				page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
				perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
				status := c.DefaultQuery("status", "active")
				search := c.Query("search")
				if status != "active" && status != "archived" && status != "all" {
					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid status"})
					return
				}

				cfgs, total, err := configService.ListAllWithStatus(page, perPage, status, search)
				if err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}

				c.JSON(http.StatusOK, gin.H{
					"configurations": cfgs,
					"total":          total,
					"page":           page,
					"per_page":       perPage,
					"status":         status,
					"search":         search,
				})
			})

			configs.POST("/import", func(c *gin.Context) {
				result, err := configService.ImportFromServer()
				if err != nil {
					if errors.Is(err, sync.ErrOffline) {
						c.JSON(http.StatusServiceUnavailable, gin.H{"error": "Database is offline"})
						return
					}
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}
				c.JSON(http.StatusOK, result)
			})

			configs.POST("", func(c *gin.Context) {
				var req services.CreateConfigRequest
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}

				config, err := configService.Create(dbUsername, &req)
				if err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}

				c.JSON(http.StatusCreated, config)
			})

			configs.POST("/preview-article", func(c *gin.Context) {
				var req services.ArticlePreviewRequest
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}
				result, err := configService.BuildArticlePreview(&req)
				if err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}
				c.JSON(http.StatusOK, gin.H{
					"article":  result.Article,
					"warnings": result.Warnings,
				})
			})

			configs.GET("/:uuid", func(c *gin.Context) {
				uuid := c.Param("uuid")
				config, err := configService.GetByUUIDNoAuth(uuid)
				if err != nil {
					c.JSON(http.StatusNotFound, gin.H{"error": "configuration not found"})
					return
				}
				c.JSON(http.StatusOK, config)
			})

			configs.PUT("/:uuid", func(c *gin.Context) {
				uuid := c.Param("uuid")
				var req services.CreateConfigRequest
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}

				config, err := configService.UpdateNoAuth(uuid, &req)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrConfigNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectForbidden):
						c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}

				c.JSON(http.StatusOK, config)
			})

			configs.DELETE("/:uuid", func(c *gin.Context) {
				uuid := c.Param("uuid")
				if err := configService.DeleteNoAuth(uuid); err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}
				c.JSON(http.StatusOK, gin.H{"message": "archived"})
			})

			configs.POST("/:uuid/reactivate", func(c *gin.Context) {
				uuid := c.Param("uuid")
				config, err := configService.ReactivateNoAuth(uuid)
				if err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}
				c.JSON(http.StatusOK, gin.H{
					"message": "reactivated",
					"config":  config,
				})
			})

			configs.PATCH("/:uuid/rename", func(c *gin.Context) {
				uuid := c.Param("uuid")
				var req struct {
					Name string `json:"name"`
				}
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}

				config, err := configService.RenameNoAuth(uuid, req.Name)
				if err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}

				c.JSON(http.StatusOK, config)
			})

			configs.POST("/:uuid/clone", func(c *gin.Context) {
				uuid := c.Param("uuid")
				var req struct {
					Name        string `json:"name"`
					FromVersion int    `json:"from_version"`
				}
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}

				config, err := configService.CloneNoAuthToProjectFromVersion(uuid, req.Name, dbUsername, nil, req.FromVersion)
				if err != nil {
					if errors.Is(err, services.ErrConfigVersionNotFound) {
						c.JSON(http.StatusNotFound, gin.H{"error": "version not found"})
						return
					}
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}

				c.JSON(http.StatusCreated, config)
			})

			configs.POST("/:uuid/refresh-prices", func(c *gin.Context) {
				uuid := c.Param("uuid")
				config, err := configService.RefreshPricesNoAuth(uuid)
				if err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}
				c.JSON(http.StatusOK, config)
			})

			configs.PATCH("/:uuid/project", func(c *gin.Context) {
				uuid := c.Param("uuid")
				var req struct {
					ProjectUUID string `json:"project_uuid"`
				}
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}
				updated, err := configService.SetProjectNoAuth(uuid, req.ProjectUUID)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrConfigNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectForbidden):
						c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}
				c.JSON(http.StatusOK, updated)
			})

			configs.GET("/:uuid/versions", func(c *gin.Context) {
				uuid := c.Param("uuid")

				limit, err := strconv.Atoi(c.DefaultQuery("limit", "20"))
				if err != nil || limit <= 0 {
					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid limit"})
					return
				}
				offset, err := strconv.Atoi(c.DefaultQuery("offset", "0"))
				if err != nil || offset < 0 {
					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid offset"})
					return
				}

				versions, err := configService.ListVersions(uuid, limit, offset)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrConfigNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": "configuration not found"})
					case errors.Is(err, services.ErrInvalidVersionNumber):
						c.JSON(http.StatusBadRequest, gin.H{"error": "invalid paging params"})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}

				c.JSON(http.StatusOK, gin.H{
					"versions": versions,
					"limit":    limit,
					"offset":   offset,
				})
			})

			configs.GET("/:uuid/versions/:version", func(c *gin.Context) {
				uuid := c.Param("uuid")
				versionNo, err := strconv.Atoi(c.Param("version"))
				if err != nil || versionNo <= 0 {
					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid version number"})
					return
				}

				version, err := configService.GetVersion(uuid, versionNo)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrInvalidVersionNumber):
						c.JSON(http.StatusBadRequest, gin.H{"error": "invalid version number"})
					case errors.Is(err, services.ErrConfigVersionNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": "version not found"})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}

				c.JSON(http.StatusOK, version)
			})

			configs.POST("/:uuid/rollback", func(c *gin.Context) {
				uuid := c.Param("uuid")
				var req struct {
					TargetVersion int    `json:"target_version"`
					Note          string `json:"note"`
				}
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}
				if req.TargetVersion <= 0 {
					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid target_version"})
					return
				}

				config, err := configService.RollbackToVersionWithNote(uuid, req.TargetVersion, dbUsername, req.Note)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrInvalidVersionNumber):
						c.JSON(http.StatusBadRequest, gin.H{"error": "invalid target_version"})
					case errors.Is(err, services.ErrConfigNotFound), errors.Is(err, services.ErrConfigVersionNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": "version not found"})
					case errors.Is(err, services.ErrVersionConflict):
						c.JSON(http.StatusConflict, gin.H{"error": "version conflict"})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}

				currentVersion, err := configService.GetCurrentVersion(uuid)
				if err != nil {
					c.JSON(http.StatusOK, gin.H{
						"message": "rollback applied",
						"config":  config,
					})
					return
				}

				c.JSON(http.StatusOK, gin.H{
					"message":         "rollback applied",
					"config":          config,
					"current_version": currentVersion,
				})
			})

			configs.GET("/:uuid/export", exportHandler.ExportConfigCSV)

			// Vendor spec (BOM) endpoints
			configs.GET("/:uuid/vendor-spec", vendorSpecHandler.GetVendorSpec)
			configs.PUT("/:uuid/vendor-spec", vendorSpecHandler.PutVendorSpec)
			configs.POST("/:uuid/vendor-spec/resolve", vendorSpecHandler.ResolveVendorSpec)
			configs.POST("/:uuid/vendor-spec/apply", vendorSpecHandler.ApplyVendorSpec)

			configs.PATCH("/:uuid/server-count", func(c *gin.Context) {
				uuid := c.Param("uuid")
				var req struct {
					ServerCount int `json:"server_count" binding:"required,min=1"`
				}
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}
				config, err := configService.UpdateServerCount(uuid, req.ServerCount)
				if err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}
				c.JSON(http.StatusOK, config)
			})
		}

		projects := api.Group("/projects")
		{
			projects.GET("", func(c *gin.Context) {
				triggerPull("projects", &projectsPullState, syncProjectsFromServer)
				triggerPull("configs", &configsPullState, syncConfigurationsFromServer)

				status := c.DefaultQuery("status", "active")
				search := strings.ToLower(strings.TrimSpace(c.Query("search")))
				author := strings.ToLower(strings.TrimSpace(c.Query("author")))
				page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
				// Return all projects by default (set high limit for configs to reference)
				perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "1000"))
				sortField := strings.ToLower(strings.TrimSpace(c.DefaultQuery("sort", "created_at")))
				sortDir := strings.ToLower(strings.TrimSpace(c.DefaultQuery("dir", "desc")))
				if status != "active" && status != "archived" && status != "all" {
					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid status"})
					return
				}
				if page < 1 {
					page = 1
				}
				if perPage < 1 {
					perPage = 10
				}
				if perPage > 100 {
					perPage = 100
				}
				if sortField != "name" && sortField != "created_at" {
					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid sort field"})
					return
				}
				if sortDir != "asc" && sortDir != "desc" {
					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid sort direction"})
					return
				}

				allProjects, err := projectService.ListByUser(dbUsername, true)
				if err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}

				filtered := make([]models.Project, 0, len(allProjects))
				for i := range allProjects {
					p := allProjects[i]
					if status == "active" && !p.IsActive {
						continue
					}
					if status == "archived" && p.IsActive {
						continue
					}
					if search != "" &&
						!strings.Contains(strings.ToLower(derefString(p.Name)), search) &&
						!strings.Contains(strings.ToLower(p.Code), search) &&
						!strings.Contains(strings.ToLower(p.Variant), search) {
						continue
					}
					if author != "" && !strings.Contains(strings.ToLower(strings.TrimSpace(p.OwnerUsername)), author) {
						continue
					}
					filtered = append(filtered, p)
				}

				sort.Slice(filtered, func(i, j int) bool {
					left := filtered[i]
					right := filtered[j]
					if sortField == "name" {
						leftName := strings.ToLower(strings.TrimSpace(derefString(left.Name)))
						rightName := strings.ToLower(strings.TrimSpace(derefString(right.Name)))
						if leftName == rightName {
							if sortDir == "asc" {
								return left.CreatedAt.Before(right.CreatedAt)
							}
							return left.CreatedAt.After(right.CreatedAt)
						}
						if sortDir == "asc" {
							return leftName < rightName
						}
						return leftName > rightName
					}
					if left.CreatedAt.Equal(right.CreatedAt) {
						leftName := strings.ToLower(strings.TrimSpace(derefString(left.Name)))
						rightName := strings.ToLower(strings.TrimSpace(derefString(right.Name)))
						if sortDir == "asc" {
							return leftName < rightName
						}
						return leftName > rightName
					}
					if sortDir == "asc" {
						return left.CreatedAt.Before(right.CreatedAt)
					}
					return left.CreatedAt.After(right.CreatedAt)
				})

				total := len(filtered)
				totalPages := 0
				if total > 0 {
					totalPages = int(math.Ceil(float64(total) / float64(perPage)))
				}
				if totalPages > 0 && page > totalPages {
					page = totalPages
				}

				start := (page - 1) * perPage
				if start < 0 {
					start = 0
				}
				end := start + perPage
				if end > total {
					end = total
				}

				paged := []models.Project{}
				if start < total {
					paged = filtered[start:end]
				}

				// Build per-project active config stats in one pass (avoid N+1 scans).
				projectConfigCount := map[string]int{}
				projectConfigTotal := map[string]float64{}
				if localConfigs, cfgErr := local.GetConfigurations(); cfgErr == nil {
					for i := range localConfigs {
						cfg := localConfigs[i]
						if !cfg.IsActive || cfg.ProjectUUID == nil || *cfg.ProjectUUID == "" {
							continue
						}
						projectUUID := *cfg.ProjectUUID
						projectConfigCount[projectUUID]++
						if cfg.TotalPrice != nil {
							projectConfigTotal[projectUUID] += *cfg.TotalPrice
						}
					}
				}

				projectRows := make([]gin.H, 0, len(paged))
				for i := range paged {
					p := paged[i]
					projectRows = append(projectRows, gin.H{
						"id":             p.ID,
						"uuid":           p.UUID,
						"owner_username": p.OwnerUsername,
						"code":           p.Code,
						"variant":        p.Variant,
						"name":           p.Name,
						"tracker_url":    p.TrackerURL,
						"is_active":      p.IsActive,
						"is_system":      p.IsSystem,
						"created_at":     p.CreatedAt,
						"updated_at":     p.UpdatedAt,
						"config_count":   projectConfigCount[p.UUID],
						"total":          projectConfigTotal[p.UUID],
					})
				}

				c.JSON(http.StatusOK, gin.H{
					"projects":    projectRows,
					"status":      status,
					"search":      search,
					"author":      author,
					"sort":        sortField,
					"dir":         sortDir,
					"page":        page,
					"per_page":    perPage,
					"total":       total,
					"total_pages": totalPages,
				})
			})

			// GET /api/projects/all - Returns all projects without pagination for UI dropdowns
			projects.GET("/all", func(c *gin.Context) {
				allProjects, err := projectService.ListByUser(dbUsername, true)
				if err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}

				// Return simplified list of all projects (UUID + Name only)
				type ProjectSimple struct {
					UUID     string `json:"uuid"`
					Code     string `json:"code"`
					Variant  string `json:"variant"`
					Name     string `json:"name"`
					IsActive bool   `json:"is_active"`
				}

				simplified := make([]ProjectSimple, 0, len(allProjects))
				for _, p := range allProjects {
					simplified = append(simplified, ProjectSimple{
						UUID:     p.UUID,
						Code:     p.Code,
						Variant:  p.Variant,
						Name:     derefString(p.Name),
						IsActive: p.IsActive,
					})
				}

				c.JSON(http.StatusOK, simplified)
			})

			projects.POST("", func(c *gin.Context) {
				var req services.CreateProjectRequest
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}
				if strings.TrimSpace(req.Code) == "" {
					c.JSON(http.StatusBadRequest, gin.H{"error": "project code is required"})
					return
				}
				project, err := projectService.Create(dbUsername, &req)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrProjectCodeExists):
						c.JSON(http.StatusConflict, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}
				c.JSON(http.StatusCreated, project)
			})

			projects.GET("/:uuid", func(c *gin.Context) {
				project, err := projectService.GetByUUID(c.Param("uuid"), dbUsername)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrProjectNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectForbidden):
						c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}
				c.JSON(http.StatusOK, project)
			})

			projects.PUT("/:uuid", func(c *gin.Context) {
				var req services.UpdateProjectRequest
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}
				project, err := projectService.Update(c.Param("uuid"), dbUsername, &req)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrProjectCodeExists):
						c.JSON(http.StatusConflict, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectForbidden):
						c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}
				c.JSON(http.StatusOK, project)
			})

			projects.POST("/:uuid/archive", func(c *gin.Context) {
				if err := projectService.Archive(c.Param("uuid"), dbUsername); err != nil {
					switch {
					case errors.Is(err, services.ErrProjectNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectForbidden):
						c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}
				c.JSON(http.StatusOK, gin.H{"message": "project archived"})
			})

			projects.POST("/:uuid/reactivate", func(c *gin.Context) {
				if err := projectService.Reactivate(c.Param("uuid"), dbUsername); err != nil {
					switch {
					case errors.Is(err, services.ErrProjectNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectForbidden):
						c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}
				c.JSON(http.StatusOK, gin.H{"message": "project reactivated"})
			})

			projects.DELETE("/:uuid", func(c *gin.Context) {
				if err := projectService.DeleteVariant(c.Param("uuid"), dbUsername); err != nil {
					switch {
					case errors.Is(err, services.ErrCannotDeleteMainVariant):
						c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectForbidden):
						c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}
				c.JSON(http.StatusOK, gin.H{"message": "variant deleted"})
			})

			projects.GET("/:uuid/configs", func(c *gin.Context) {
				triggerPull("configs", &configsPullState, syncConfigurationsFromServer)

				status := c.DefaultQuery("status", "active")
				if status != "active" && status != "archived" && status != "all" {
					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid status"})
					return
				}

				result, err := projectService.ListConfigurations(c.Param("uuid"), dbUsername, status)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrProjectNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					case errors.Is(err, services.ErrProjectForbidden):
						c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					}
					return
				}
				c.Header("X-Config-Status", status)
				c.JSON(http.StatusOK, result)
			})

			projects.PATCH("/:uuid/configs/reorder", func(c *gin.Context) {
				var req struct {
					OrderedUUIDs []string `json:"ordered_uuids"`
				}
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}
				if len(req.OrderedUUIDs) == 0 {
					c.JSON(http.StatusBadRequest, gin.H{"error": "ordered_uuids is required"})
					return
				}

				configs, err := configService.ReorderProjectConfigurationsNoAuth(c.Param("uuid"), req.OrderedUUIDs)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrProjectNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					}
					return
				}

				total := 0.0
				for i := range configs {
					if configs[i].TotalPrice != nil {
						total += *configs[i].TotalPrice
					}
				}
				c.JSON(http.StatusOK, gin.H{
					"project_uuid":   c.Param("uuid"),
					"configurations": configs,
					"total":          total,
				})
			})

			projects.POST("/:uuid/configs", func(c *gin.Context) {
				var req services.CreateConfigRequest
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}
				projectUUID := c.Param("uuid")
				req.ProjectUUID = &projectUUID

				config, err := configService.Create(dbUsername, &req)
				if err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}
				c.JSON(http.StatusCreated, config)
			})

			projects.POST("/:uuid/vendor-import", func(c *gin.Context) {
				fileHeader, err := c.FormFile("file")
				if err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": "file is required"})
					return
				}

				file, err := fileHeader.Open()
				if err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": "failed to open uploaded file"})
					return
				}
				defer file.Close()

				data, err := io.ReadAll(file)
				if err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": "failed to read uploaded file"})
					return
				}
				if !services.IsCFXMLWorkspace(data) {
					c.JSON(http.StatusBadRequest, gin.H{"error": "unsupported vendor export format"})
					return
				}

				result, err := configService.ImportVendorWorkspaceToProject(c.Param("uuid"), fileHeader.Filename, data, dbUsername)
				if err != nil {
					switch {
					case errors.Is(err, services.ErrProjectNotFound):
						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
					default:
						c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					}
					return
				}

				c.JSON(http.StatusCreated, result)
			})

			projects.GET("/:uuid/export", exportHandler.ExportProjectCSV)
			projects.POST("/:uuid/export", exportHandler.ExportProjectPricingCSV)

			projects.POST("/:uuid/configs/:config_uuid/clone", func(c *gin.Context) {
				var req struct {
					Name string `json:"name"`
				}
				if err := c.ShouldBindJSON(&req); err != nil {
					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
					return
				}

				projectUUID := c.Param("uuid")
				config, err := configService.CloneNoAuthToProject(c.Param("config_uuid"), req.Name, dbUsername, &projectUUID)
				if err != nil {
					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
					return
				}
				c.JSON(http.StatusCreated, config)
			})
		}

		// Sync API (for offline mode)
		syncAPI := api.Group("/sync")
		{
			syncAPI.GET("/status", syncHandler.GetStatus)
			syncAPI.GET("/readiness", syncHandler.GetReadiness)
			syncAPI.GET("/info", syncHandler.GetInfo)
			syncAPI.GET("/users-status", syncHandler.GetUsersStatus)
			syncAPI.POST("/components", syncHandler.SyncComponents)
			syncAPI.POST("/pricelists", syncHandler.SyncPricelists)
			syncAPI.POST("/partnumber-books", syncHandler.SyncPartnumberBooks)
			syncAPI.POST("/partnumber-seen", syncHandler.ReportPartnumberSeen)
			syncAPI.POST("/all", syncHandler.SyncAll)
			syncAPI.POST("/push", syncHandler.PushPendingChanges)
			syncAPI.GET("/pending/count", syncHandler.GetPendingCount)
			syncAPI.GET("/pending", syncHandler.GetPendingChanges)
			syncAPI.POST("/repair", syncHandler.RepairPendingChanges)
		}
	}

	return router, syncService, nil
}

// restartProcess restarts the current process with the same arguments
func restartProcess() {
	executable, err := os.Executable()
	if err != nil {
		slog.Error("failed to get executable path", "error", err)
		os.Exit(1)
	}

	args := os.Args
	env := os.Environ()

	slog.Info("executing restart", "executable", executable, "args", args)

	err = syscall.Exec(executable, args, env)
	if err != nil {
		slog.Error("failed to restart process", "error", err)
		os.Exit(1)
	}
}

func openBrowser(url string) error {
	var cmd string
	var args []string

	switch runtime.GOOS {
	case "windows":
		cmd = "cmd"
		args = []string{"/c", "start", url}
	case "darwin":
		cmd = "open"
		args = []string{url}
	default: // "linux", "freebsd", "openbsd", "netbsd"
		cmd = "xdg-open"
		args = []string{url}
	}

	return exec.Command(cmd, args...).Start()
}

func requestLogger() gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		path := c.Request.URL.Path
		query := c.Request.URL.RawQuery

		blw := &captureResponseWriter{
			ResponseWriter: c.Writer,
			body:           bytes.NewBuffer(nil),
		}
		c.Writer = blw

		c.Next()

		latency := time.Since(start)
		status := c.Writer.Status()

		if status >= http.StatusBadRequest {
			responseBody := strings.TrimSpace(blw.body.String())
			if len(responseBody) > 2048 {
				responseBody = responseBody[:2048] + "...(truncated)"
			}
			errText := strings.TrimSpace(c.Errors.String())

			slog.Error("request failed",
				"method", c.Request.Method,
				"path", path,
				"query", query,
				"status", status,
				"latency", latency,
				"ip", c.ClientIP(),
				"errors", errText,
				"response", responseBody,
			)
			return
		}

		slog.Info("request",
			"method", c.Request.Method,
			"path", path,
			"query", query,
			"status", status,
			"latency", latency,
			"ip", c.ClientIP(),
		)
	}
}

type captureResponseWriter struct {
	gin.ResponseWriter
	body *bytes.Buffer
}

func (w *captureResponseWriter) Write(b []byte) (int, error) {
	if len(b) > 0 {
		_, _ = w.body.Write(b)
	}
	return w.ResponseWriter.Write(b)
}

func (w *captureResponseWriter) WriteString(s string) (int, error) {
	if s != "" {
		_, _ = w.body.WriteString(s)
	}
	return w.ResponseWriter.WriteString(s)
}