// Package server wires the HTTP surface of the Email Agent.
//
// Phase 1 exposes liveness/readiness endpoints and a placeholder dashboard.
// Login and the real HTMX screens arrive in Phase 1.2.
package server

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"html/template"
	"log/slog"
	"net/http"
	"time"

	"gitea.lab.audasmedia.com.au/sam/email_agent/internal/config"
	"gitea.lab.audasmedia.com.au/sam/email_agent/internal/store"
	"gitea.lab.audasmedia.com.au/sam/email_agent/internal/version"
)

// Server holds the HTTP dependencies.
type Server struct {
	cfg    *config.Config
	store  *store.Store
	logger *slog.Logger
	http   *http.Server
	index  *template.Template
}

// New builds a Server. It does not start listening.
func New(cfg *config.Config, st *store.Store, logger *slog.Logger) (*Server, error) {
	index, err := template.New("index").Parse(indexHTML)
	if err != nil {
		return nil, fmt.Errorf("parse index template: %w", err)
	}

	s := &Server{
		cfg:    cfg,
		store:  st,
		logger: logger,
		index:  index,
	}
	s.http = &http.Server{
		Addr:              cfg.Addr,
		Handler:           s.Handler(),
		ReadHeaderTimeout: 10 * time.Second,
		ReadTimeout:       30 * time.Second,
		WriteTimeout:      30 * time.Second,
		IdleTimeout:       60 * time.Second,
	}
	return s, nil
}

// Handler returns the root HTTP handler with middleware applied.
func (s *Server) Handler() http.Handler {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /health", s.handleHealth)
	mux.HandleFunc("GET /readyz", s.handleReady)
	mux.HandleFunc("GET /{$}", s.handleIndex)
	return s.recoverPanic(s.logRequests(mux))
}

// Run starts the HTTP server and blocks until ctx is cancelled.
func (s *Server) Run(ctx context.Context) error {
	errCh := make(chan error, 1)
	go func() {
		s.logger.Info("http server listening",
			"addr", s.cfg.Addr,
			"env", s.cfg.Env,
			"db", s.store.Path(),
			"version", version.Version,
		)
		if err := s.http.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			errCh <- err
			return
		}
		errCh <- nil
	}()

	select {
	case err := <-errCh:
		return err
	case <-ctx.Done():
		shutdownCtx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
		defer cancel()
		s.logger.Info("shutting down http server")
		return s.http.Shutdown(shutdownCtx)
	}
}

type healthResponse struct {
	Status        string `json:"status"`
	Version       string `json:"version"`
	Commit        string `json:"commit"`
	Env           string `json:"env"`
	UptimeSeconds int64  `json:"uptime_seconds"`
	Database      string `json:"database"`
	Time          string `json:"time"`
}

var startedAt = time.Now()

// handleHealth reports liveness plus a database connectivity check.
func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
	ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
	defer cancel()

	resp := healthResponse{
		Status:        "ok",
		Version:       version.Version,
		Commit:        version.Commit,
		Env:           s.cfg.Env,
		UptimeSeconds: int64(time.Since(startedAt).Seconds()),
		Database:      "ok",
		Time:          time.Now().UTC().Format(time.RFC3339),
	}
	code := http.StatusOK

	if err := s.store.Ping(ctx); err != nil {
		s.logger.Error("health check: database unreachable", "error", err)
		resp.Status = "degraded"
		resp.Database = "unreachable"
		code = http.StatusServiceUnavailable
	}

	writeJSON(w, code, resp)
}

// handleReady reports readiness for load balancers (same signal as health).
func (s *Server) handleReady(w http.ResponseWriter, r *http.Request) {
	ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
	defer cancel()
	if err := s.store.Ping(ctx); err != nil {
		writeJSON(w, http.StatusServiceUnavailable, map[string]string{"status": "not ready"})
		return
	}
	writeJSON(w, http.StatusOK, map[string]string{"status": "ready"})
}

// handleIndex renders a placeholder dashboard. The real login + inbox screens
// are Phase 1.2.
func (s *Server) handleIndex(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	data := struct {
		Version string
		Env     string
	}{Version: version.Version, Env: s.cfg.Env}
	if err := s.index.Execute(w, data); err != nil {
		s.logger.Error("render index", "error", err)
	}
}

func writeJSON(w http.ResponseWriter, code int, v any) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.WriteHeader(code)
	_ = json.NewEncoder(w).Encode(v)
}

// logRequests logs one line per request at debug level.
func (s *Server) logRequests(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
		next.ServeHTTP(rec, r)
		s.logger.Debug("request",
			"method", r.Method,
			"path", r.URL.Path,
			"status", rec.status,
			"duration_ms", time.Since(start).Milliseconds(),
			"remote", r.RemoteAddr,
		)
	})
}

// recoverPanic keeps one bad request from taking down the process.
func (s *Server) recoverPanic(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if rec := recover(); rec != nil {
				s.logger.Error("panic recovered", "error", rec, "path", r.URL.Path)
				http.Error(w, "internal server error", http.StatusInternalServerError)
			}
		}()
		next.ServeHTTP(w, r)
	})
}

type statusRecorder struct {
	http.ResponseWriter
	status int
}

func (r *statusRecorder) WriteHeader(code int) {
	r.status = code
	r.ResponseWriter.WriteHeader(code)
}

const indexHTML = `<!doctype html>
<html lang="en" data-theme="light">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Email Agent</title>
<style>
  :root { color-scheme: light dark; }
  body { font-family: Inter, -apple-system, system-ui, "Segoe UI", Helvetica, Arial, sans-serif;
         background: #f6f5f4; color: #31302e; margin: 0; }
  @media (prefers-color-scheme: dark) { body { background: #141518; color: #dcdee2; } }
  main { max-width: 640px; margin: 12vh auto; padding: 0 24px; }
  .band { background: #213183; color: #fff; border-radius: 12px; padding: 24px; }
  h1 { font-size: 32px; line-height: 1.1; margin: 0 0 8px; }
  p { font-size: 15px; line-height: 1.5; }
  code { background: rgba(127,127,127,.15); padding: 2px 6px; border-radius: 4px; }
</style>
</head>
<body>
<main>
  <div class="band">
    <h1>Email Agent</h1>
    <p>Phase 1 skeleton is running. Version <code>{{.Version}}</code> ({{.Env}}).</p>
  </div>
  <p>Login and the inbox arrive in Phase 1.2. Liveness is at
     <a href="/health">/health</a>.</p>
</main>
</body>
</html>
`