package app

import (
	"context"
	"errors"
	"fmt"
	"log/slog"
	"net/http"
	"time"

	"git.warky.dev/wdevs/amcs/internal/ai"
	"git.warky.dev/wdevs/amcs/internal/auth"
	"git.warky.dev/wdevs/amcs/internal/config"
	"git.warky.dev/wdevs/amcs/internal/mcpserver"
	"git.warky.dev/wdevs/amcs/internal/observability"
	"git.warky.dev/wdevs/amcs/internal/session"
	"git.warky.dev/wdevs/amcs/internal/store"
	"git.warky.dev/wdevs/amcs/internal/tools"
)

func Run(ctx context.Context, configPath string) error {
	cfg, loadedFrom, err := config.Load(configPath)
	if err != nil {
		return err
	}

	logger, err := observability.NewLogger(cfg.Logging)
	if err != nil {
		return err
	}

	logger.Info("loaded configuration",
		slog.String("path", loadedFrom),
		slog.String("provider", cfg.AI.Provider),
	)

	db, err := store.New(ctx, cfg.Database)
	if err != nil {
		return err
	}
	defer db.Close()

	if err := db.VerifyRequirements(ctx); err != nil {
		return err
	}

	httpClient := &http.Client{Timeout: 30 * time.Second}
	provider, err := ai.NewProvider(cfg.AI, httpClient, logger)
	if err != nil {
		return err
	}

	var keyring *auth.Keyring
	var oauthRegistry *auth.OAuthRegistry
	var tokenStore *auth.TokenStore
	if len(cfg.Auth.Keys) > 0 {
		keyring, err = auth.NewKeyring(cfg.Auth.Keys)
		if err != nil {
			return err
		}
	}
	if len(cfg.Auth.OAuth.Clients) > 0 {
		oauthRegistry, err = auth.NewOAuthRegistry(cfg.Auth.OAuth.Clients)
		if err != nil {
			return err
		}
		tokenStore = auth.NewTokenStore(0)
	}
	authCodes := auth.NewAuthCodeStore()
	dynClients := auth.NewDynamicClientStore()
	activeProjects := session.NewActiveProjects()

	logger.Info("database connection verified",
		slog.String("provider", provider.Name()),
	)

	if cfg.Backfill.Enabled && cfg.Backfill.RunOnStartup {
		go runBackfillPass(ctx, db, provider, cfg.Backfill, logger)
	}

	if cfg.Backfill.Enabled && cfg.Backfill.Interval > 0 {
		go func() {
			ticker := time.NewTicker(cfg.Backfill.Interval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					runBackfillPass(ctx, db, provider, cfg.Backfill, logger)
				}
			}
		}()
	}

	if cfg.MetadataRetry.Enabled && cfg.MetadataRetry.RunOnStartup {
		go runMetadataRetryPass(ctx, db, provider, cfg, activeProjects, logger)
	}

	if cfg.MetadataRetry.Enabled && cfg.MetadataRetry.Interval > 0 {
		go func() {
			ticker := time.NewTicker(cfg.MetadataRetry.Interval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					runMetadataRetryPass(ctx, db, provider, cfg, activeProjects, logger)
				}
			}
		}()
	}

	server := &http.Server{
		Addr:         fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port),
		Handler:      routes(logger, cfg, db, provider, keyring, oauthRegistry, tokenStore, authCodes, dynClients, activeProjects),
		ReadTimeout:  cfg.Server.ReadTimeout,
		WriteTimeout: cfg.Server.WriteTimeout,
		IdleTimeout:  cfg.Server.IdleTimeout,
	}

	errCh := make(chan error, 1)
	go func() {
		logger.Info("starting HTTP server",
			slog.String("addr", server.Addr),
			slog.String("mcp_path", cfg.MCP.Path),
		)

		if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			errCh <- err
		}
	}()

	select {
	case <-ctx.Done():
		shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()

		logger.Info("shutting down HTTP server")
		return server.Shutdown(shutdownCtx)
	case err := <-errCh:
		return fmt.Errorf("run server: %w", err)
	}
}

func routes(logger *slog.Logger, cfg *config.Config, db *store.DB, provider ai.Provider, keyring *auth.Keyring, oauthRegistry *auth.OAuthRegistry, tokenStore *auth.TokenStore, authCodes *auth.AuthCodeStore, dynClients *auth.DynamicClientStore, activeProjects *session.ActiveProjects) http.Handler {
	mux := http.NewServeMux()
	authMiddleware := auth.Middleware(cfg.Auth, keyring, oauthRegistry, tokenStore, logger)
	filesTool := tools.NewFilesTool(db, activeProjects)
	metadataRetryer := tools.NewMetadataRetryer(context.Background(), db, provider, cfg.Capture, cfg.AI.Metadata.Timeout, activeProjects, logger)

	toolSet := mcpserver.ToolSet{
		Capture:       tools.NewCaptureTool(db, provider, cfg.Capture, cfg.AI.Metadata.Timeout, activeProjects, metadataRetryer, logger),
		Search:        tools.NewSearchTool(db, provider, cfg.Search, activeProjects),
		List:          tools.NewListTool(db, cfg.Search, activeProjects),
		Stats:         tools.NewStatsTool(db),
		Get:           tools.NewGetTool(db),
		Update:        tools.NewUpdateTool(db, provider, cfg.Capture, logger),
		Delete:        tools.NewDeleteTool(db),
		Archive:       tools.NewArchiveTool(db),
		Projects:      tools.NewProjectsTool(db, activeProjects),
		Context:       tools.NewContextTool(db, provider, cfg.Search, activeProjects),
		Recall:        tools.NewRecallTool(db, provider, cfg.Search, activeProjects),
		Summarize:     tools.NewSummarizeTool(db, provider, cfg.Search, activeProjects),
		Links:         tools.NewLinksTool(db, provider, cfg.Search),
		Files:         filesTool,
		Backfill:      tools.NewBackfillTool(db, provider, activeProjects, logger),
		Reparse:       tools.NewReparseMetadataTool(db, provider, cfg.Capture, activeProjects, logger),
		RetryMetadata: tools.NewRetryMetadataTool(metadataRetryer),
		Household:     tools.NewHouseholdTool(db),
		Maintenance:   tools.NewMaintenanceTool(db),
		Calendar:      tools.NewCalendarTool(db),
		Meals:         tools.NewMealsTool(db),
		CRM:           tools.NewCRMTool(db),
	}

	mcpHandler := mcpserver.New(cfg.MCP, toolSet)
	mux.Handle(cfg.MCP.Path, authMiddleware(mcpHandler))
	mux.Handle("/files", authMiddleware(fileUploadHandler(filesTool)))
	if oauthRegistry != nil && tokenStore != nil {
		mux.HandleFunc("/.well-known/oauth-authorization-server", oauthMetadataHandler())
		mux.HandleFunc("/oauth-authorization-server", oauthMetadataHandler())
		mux.HandleFunc("/oauth/register", oauthRegisterHandler(dynClients, logger))
		mux.HandleFunc("/authorize", oauthAuthorizeHandler(dynClients, authCodes, logger))
		mux.HandleFunc("/oauth/authorize", oauthAuthorizeHandler(dynClients, authCodes, logger))
		mux.HandleFunc("/oauth/token", oauthTokenHandler(oauthRegistry, tokenStore, authCodes, logger))
	}
	mux.HandleFunc("/favicon.ico", serveFavicon)
	mux.HandleFunc("/images/project.jpg", serveHomeImage)
	mux.HandleFunc("/llm", serveLLMInstructions)

	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("ok"))
	})

	mux.HandleFunc("/readyz", func(w http.ResponseWriter, r *http.Request) {
		if err := db.Ready(r.Context()); err != nil {
			logger.Error("readiness check failed", slog.String("error", err.Error()))
			http.Error(w, "not ready", http.StatusServiceUnavailable)
			return
		}

		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("ready"))
	})

	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/" {
			http.NotFound(w, r)
			return
		}

		if r.Method != http.MethodGet && r.Method != http.MethodHead {
			w.Header().Set("Allow", "GET, HEAD")
			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
			return
		}

		const homePage = `<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>AMCS</title>
  <style>
    body { margin: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #f5f7fb; color: #172033; }
    main { max-width: 860px; margin: 48px auto; background: #fff; border-radius: 12px; box-shadow: 0 10px 28px rgba(23, 32, 51, 0.12); overflow: hidden; }
    .content { padding: 28px; }
    h1 { margin: 0 0 12px 0; font-size: 2rem; }
    p { margin: 0; line-height: 1.5; color: #334155; }
    .actions { margin-top: 18px; }
    .link { display: inline-block; padding: 10px 14px; border-radius: 8px; background: #172033; color: #fff; text-decoration: none; font-weight: 600; }
    .link:hover { background: #0f172a; }
    img { display: block; width: 100%; height: auto; }
  </style>
</head>
<body>
  <main>
    <img src="/images/project.jpg" alt="Avelon Memory Crystal project image">
    <div class="content">
      <h1>Avelon Memory Crystal Server (AMCS)</h1>
      <p>AMCS is a memory server that captures, links, and retrieves structured project thoughts for AI assistants using semantic search, summaries, and MCP tools.</p>
      <div class="actions">
        <a class="link" href="/llm">LLM Instructions</a>
        <a class="link" href="/oauth-authorization-server">OAuth Authorization Server</a>
        <a class="link" href="/healthz">Health Check</a>
      </div>
    </div>
  </main>
</body>
</html>`
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		w.WriteHeader(http.StatusOK)
		if r.Method == http.MethodHead {
			return
		}

		_, _ = w.Write([]byte(homePage))
	})

	return observability.Chain(
		mux,
		observability.RequestID(),
		observability.Recover(logger),
		observability.AccessLog(logger),
		observability.Timeout(cfg.Server.WriteTimeout),
	)
}

func runMetadataRetryPass(ctx context.Context, db *store.DB, provider ai.Provider, cfg *config.Config, activeProjects *session.ActiveProjects, logger *slog.Logger) {
	retryer := tools.NewMetadataRetryer(ctx, db, provider, cfg.Capture, cfg.AI.Metadata.Timeout, activeProjects, logger)
	_, out, err := retryer.Handle(ctx, nil, tools.RetryMetadataInput{
		Limit:           cfg.MetadataRetry.MaxPerRun,
		IncludeArchived: cfg.MetadataRetry.IncludeArchived,
		OlderThanDays:   1,
	})
	if err != nil {
		logger.Error("auto metadata retry failed", slog.String("error", err.Error()))
		return
	}
	logger.Info("auto metadata retry pass",
		slog.Int("scanned", out.Scanned),
		slog.Int("retried", out.Retried),
		slog.Int("updated", out.Updated),
		slog.Int("failed", out.Failed),
	)
}

func runBackfillPass(ctx context.Context, db *store.DB, provider ai.Provider, cfg config.BackfillConfig, logger *slog.Logger) {
	backfiller := tools.NewBackfillTool(db, provider, nil, logger)
	_, out, err := backfiller.Handle(ctx, nil, tools.BackfillInput{
		Limit:           cfg.MaxPerRun,
		IncludeArchived: cfg.IncludeArchived,
	})
	if err != nil {
		logger.Error("auto backfill failed", slog.String("error", err.Error()))
		return
	}
	logger.Info("auto backfill pass",
		slog.String("model", out.Model),
		slog.Int("scanned", out.Scanned),
		slog.Int("embedded", out.Embedded),
		slog.Int("failed", out.Failed),
	)
}

func serveHomeImage(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet && r.Method != http.MethodHead {
		w.Header().Set("Allow", "GET, HEAD")
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
		return
	}

	w.Header().Set("Content-Type", "image/jpeg")
	w.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
	w.WriteHeader(http.StatusOK)

	if r.Method == http.MethodHead {
		return
	}

	_, _ = w.Write(homeImage)
}