// Module viewLogs — streaming journalctl via WebSocket.
// Dépôt indépendant : https://git.geronzi.fr/proxmoxPanel/viewLogs
package viewlogs

import (
	_ "embed"
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
	"strings"

	"git.geronzi.fr/proxmoxPanel/core/backend/modules"
	gorillaws "github.com/gorilla/websocket"
)

//go:embed frontend/logs.html
var logsHTML []byte

// LogsModule gère la lecture des journaux systemd via journalctl.
type LogsModule struct{}

// New crée un LogsModule.
func New() *LogsModule { return &LogsModule{} }

func (m *LogsModule) ID() string { return "viewLogs" }

// Register enregistre les routes du module dans le CORE.
func (m *LogsModule) Register(r modules.Registry) error {
	r.RegisterNavItem(modules.NavItemDef{
		ID:       "viewLogs",
		Href:     "/viewLogs/logs.html",
		Icon:     "lnid-scroll-angular-1",
		Color:    "#38bdf8",
		LabelKey: "nav.logs",
	})
	r.RegisterPublicRoute("GET", "/viewLogs/logs.html", func(w http.ResponseWriter, req *http.Request) {
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		w.Write(logsHTML)
	})
	r.RegisterRoute("GET", "/api/logs/units", m.listUnits(r), false)
	r.RegisterRoute("GET", "/ws/logs", m.streamLogs(r), false)
	return nil
}

// listUnits retourne la liste des unités systemd présentes dans les journaux.
func (m *LogsModule) listUnits(r modules.Registry) http.HandlerFunc {
	return func(w http.ResponseWriter, req *http.Request) {
		target := req.URL.Query().Get("target")
		if target == "" {
			target = "host"
		}
		out, _ := r.RunOnTarget(target, "journalctl --field=_SYSTEMD_UNIT --no-pager 2>/dev/null | sort -u | head -300")
		units := []string{}
		for _, line := range strings.Split(out, "\n") {
			line = strings.TrimSpace(line)
			if line != "" {
				units = append(units, line)
			}
		}
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(units)
	}
}

// wsUpgrader pour les WebSockets du module.
var wsUpgrader = gorillaws.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}

// streamLogs ouvre un WebSocket et stream journalctl via SSH.
func (m *LogsModule) streamLogs(r modules.Registry) http.HandlerFunc {
	return func(w http.ResponseWriter, req *http.Request) {
		target := req.URL.Query().Get("target")
		if target == "" {
			target = "host"
		}
		unit := sanitizeUnit(req.URL.Query().Get("unit"))
		linesStr := req.URL.Query().Get("lines")
		lines := 100
		if n, err := strconv.Atoi(linesStr); err == nil && n > 0 && n <= 2000 {
			lines = n
		}

		conn, err := wsUpgrader.Upgrade(w, req, nil)
		if err != nil {
			return
		}
		defer conn.Close()

		args := fmt.Sprintf("-f --no-pager -n %d", lines)
		if unit != "" {
			args += " -u " + unit
		}

		// Pour les cibles LXC, StreamOnTarget wrappera via pct exec
		// On passe la commande journalctl directement ; buildTargetCmd dans le registry gère le wrapping
		cmd := "journalctl " + args

		output := make(chan string, 100)
		if err := r.StreamOnTarget(target, cmd, output); err != nil {
			conn.WriteMessage(gorillaws.TextMessage, []byte("Erreur : "+err.Error()))
			return
		}

		done := make(chan struct{})
		go func() {
			defer close(done)
			for chunk := range output {
				if err := conn.WriteMessage(gorillaws.TextMessage, []byte(chunk)); err != nil {
					break
				}
			}
		}()

		// Attendre fermeture WS
		for {
			_, _, err := conn.ReadMessage()
			if err != nil {
				break
			}
		}
		<-done
	}
}

func sanitizeUnit(unit string) string {
	for _, c := range unit {
		ok := (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
			(c >= '0' && c <= '9') || c == '-' || c == '.' || c == '_' || c == '@' || c == ':'
		if !ok {
			return ""
		}
	}
	return unit
}