deklarix/internal/web/betreiber_handlers.go

package web

import (
	"net/http"
	"strings"
	"time"

	"github.com/netcell-it/deklarix/internal/auth"
	"github.com/netcell-it/deklarix/internal/store"
)

type betreiberDashboardData struct {
	Title            string
	Nav              navData
	AccountCount     int
	WerkzeugCount    int
	RecentAuditCount int
}

// handleBetreiberDashboard zeigt eine kurze Übersicht als Einstieg in
// den Plattform-Bereich (Ebene 5 — nur Betreiber, technisch getrennt
// vom Mandantenbereich).
func (s *Server) handleBetreiberDashboard(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	accounts, err := s.store.ListAccounts(ctx)
	if err != nil {
		http.Error(w, "Accounts konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
		return
	}
	werkzeuge, err := s.store.ListZentraleWerkzeuge(ctx)
	if err != nil {
		http.Error(w, "Werkzeugkatalog konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
		return
	}
	auditLog, err := s.store.ListAuditLog(ctx, 5)
	if err != nil {
		http.Error(w, "Audit-Log konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
		return
	}

	data := betreiberDashboardData{
		Title: "Plattform", Nav: navFor(r), AccountCount: len(accounts),
		WerkzeugCount: len(werkzeuge), RecentAuditCount: len(auditLog),
	}
	if err := s.templates.ExecuteTemplate(w, "betreiber-dashboard", data); err != nil {
		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
	}
}

type betreiberAccountListItem struct {
	ID        string
	Name      string
	CreatedAt string
}

type betreiberAccountListData struct {
	Title      string
	Nav        navData
	Accounts   []betreiberAccountListItem
	Suche      string
	Pagination pagination
}

// handleBetreiberAccountList listet alle Mandanten der Plattform.
func (s *Server) handleBetreiberAccountList(w http.ResponseWriter, r *http.Request) {
	accounts, err := s.store.ListAccounts(r.Context())
	if err != nil {
		http.Error(w, "Accounts konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
		return
	}
	q := strings.TrimSpace(r.URL.Query().Get("q"))
	var gefiltert []store.Account
	for _, a := range accounts {
		if matchesQuery(q, a.Name) {
			gefiltert = append(gefiltert, a)
		}
	}
	pag := paginationFromRequest(r, len(gefiltert))
	data := betreiberAccountListData{Title: "Accounts", Nav: navFor(r), Suche: q, Pagination: pag}
	for _, a := range paginate(gefiltert, pag) {
		data.Accounts = append(data.Accounts, betreiberAccountListItem{
			ID: a.ID, Name: a.Name, CreatedAt: a.CreatedAt.Format("02.01.2006 15:04"),
		})
	}
	if err := s.templates.ExecuteTemplate(w, "betreiber-accounts", data); err != nil {
		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
	}
}

type betreiberAccountNeuData struct {
	Title string
	Nav   navData
	Error string
}

func (s *Server) handleBetreiberAccountNeuForm(w http.ResponseWriter, r *http.Request) {
	data := betreiberAccountNeuData{Title: "Firma anlegen", Nav: navFor(r)}
	if err := s.templates.ExecuteTemplate(w, "betreiber-account-neu", data); err != nil {
		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
	}
}

// handleBetreiberAccountCreate legt eine Firma samt erstem admin-Login
// an — dasselbe Ergebnis wie die öffentliche Firma-Registrierung
// (handleRegister), nur vom Betreiber ausgelöst statt von der Firma
// selbst (z. B. bei vertriebsunterstütztem Onboarding oder zum Anlegen
// eines Testkontos). Der Betreiber setzt das Initialpasswort direkt,
// wie überall sonst im Produkt ohne E-Mail-Infrastruktur.
func (s *Server) handleBetreiberAccountCreate(w http.ResponseWriter, r *http.Request) {
	if err := r.ParseForm(); err != nil {
		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
		return
	}
	accountInput := store.AccountInput{
		Name:           r.FormValue("account_name"),
		Strasse:        r.FormValue("strasse"),
		PLZ:            r.FormValue("plz"),
		Ort:            r.FormValue("ort"),
		Land:           r.FormValue("land"),
		UStID:          r.FormValue("ust_id"), // optional, siehe Migration 0023 (Kleinunternehmer)
		Rechnungsemail: r.FormValue("rechnungsemail"),
	}
	email := r.FormValue("email")
	password := r.FormValue("password")
	if accountInput.Name == "" || email == "" || password == "" ||
		accountInput.Strasse == "" || accountInput.PLZ == "" || accountInput.Ort == "" ||
		accountInput.Land == "" || accountInput.Rechnungsemail == "" {
		data := betreiberAccountNeuData{Title: "Firma anlegen", Nav: navFor(r), Error: "Alle Felder außer USt-IdNr. sind Pflicht"}
		if err := s.templates.ExecuteTemplate(w, "betreiber-account-neu", data); err != nil {
			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
		}
		return
	}

	passwordHash, err := auth.HashPassword(password)
	if err != nil {
		data := betreiberAccountNeuData{Title: "Firma anlegen", Nav: navFor(r), Error: err.Error()}
		if err := s.templates.ExecuteTemplate(w, "betreiber-account-neu", data); err != nil {
			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
		}
		return
	}

	ctx := r.Context()
	acc, err := s.store.CreateAccount(ctx, accountInput)
	if err != nil {
		data := betreiberAccountNeuData{Title: "Firma anlegen", Nav: navFor(r), Error: "Konto konnte nicht angelegt werden: " + err.Error()}
		if err := s.templates.ExecuteTemplate(w, "betreiber-account-neu", data); err != nil {
			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
		}
		return
	}
	if _, err := s.store.CreateUser(ctx, acc.ID, email, passwordHash, "admin"); err != nil {
		data := betreiberAccountNeuData{Title: "Firma anlegen", Nav: navFor(r), Error: "Nutzer konnte nicht angelegt werden — E-Mail evtl. schon vergeben"}
		if err := s.templates.ExecuteTemplate(w, "betreiber-account-neu", data); err != nil {
			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
		}
		return
	}
	if err := s.seedStandardGenehmigerRollen(ctx, acc.ID); err != nil {
		data := betreiberAccountNeuData{Title: "Firma anlegen", Nav: navFor(r), Error: "Genehmiger-Rollen konnten nicht angelegt werden: " + err.Error()}
		if err := s.templates.ExecuteTemplate(w, "betreiber-account-neu", data); err != nil {
			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
		}
		return
	}
	if err := s.seedStandardLoeschfristen(ctx, acc.ID); err != nil {
		data := betreiberAccountNeuData{Title: "Firma anlegen", Nav: navFor(r), Error: "Löschfristen konnten nicht angelegt werden: " + err.Error()}
		if err := s.templates.ExecuteTemplate(w, "betreiber-account-neu", data); err != nil {
			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
		}
		return
	}
	if _, err := s.store.CreateAuditEntry(ctx, currentUser(r).ID, "betreiber_firma_angelegt", "account", acc.ID, accountInput.Name+" / "+email); err != nil {
		http.Error(w, "Audit-Log konnte nicht geschrieben werden: "+err.Error(), http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, "/betreiber/accounts/"+acc.ID, http.StatusSeeOther)
}

// handleBetreiberAccountRename benennt eine Firma um (z. B. Tippfehler
// korrigieren) — kein sonstiges Bearbeiten, Löschen bleibt bewusst
// ungebaut (siehe CLAUDE.md, Offene Punkte: hängt an der noch nicht
// getroffenen Abrechnungs-/Freischaltungs-Architektur, und ein
// Hard-Delete würde gegen die Fremdschlüssel aus antrag/app_user/
// audit_log laufen).
func (s *Server) handleBetreiberAccountRename(w http.ResponseWriter, r *http.Request) {
	if err := r.ParseForm(); err != nil {
		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
		return
	}
	name := r.FormValue("name")
	if name == "" {
		http.Error(w, "Name ist Pflicht", http.StatusBadRequest)
		return
	}
	id := r.PathValue("id")
	if _, err := s.store.UpdateAccount(r.Context(), id, name); err != nil {
		http.Error(w, "Firma konnte nicht umbenannt werden: "+err.Error(), http.StatusInternalServerError)
		return
	}
	http.Redirect(w, r, "/betreiber/accounts/"+id, http.StatusSeeOther)
}

type betreiberUserView struct {
	ID     string
	Email  string
	Role   string
	Active bool
}

type betreiberAccountDetailData struct {
	Title     string
	Nav       navData
	AccountID string
	Name      string
	Users     []betreiberUserView
	CreatedAt string
}

// handleBetreiberAccountDetail zeigt einen Mandanten mit seinen Logins.
func (s *Server) handleBetreiberAccountDetail(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	acc, err := s.store.GetAccount(ctx, r.PathValue("id"))
	if err != nil {
		http.Error(w, "Account nicht gefunden", http.StatusNotFound)
		return
	}
	users, err := s.store.ListUsersForAccount(ctx, acc.ID)
	if err != nil {
		http.Error(w, "Nutzer konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
		return
	}

	data := betreiberAccountDetailData{
		Title: "Account", Nav: navFor(r), AccountID: acc.ID, Name: acc.Name,
		CreatedAt: acc.CreatedAt.Format("02.01.2006 15:04"),
	}
	for _, u := range users {
		data.Users = append(data.Users, betreiberUserView{ID: u.ID, Email: u.Email, Role: u.Role, Active: u.Active})
	}
	if err := s.templates.ExecuteTemplate(w, "betreiber-account-detail", data); err != nil {
		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
	}
}

type betreiberAuditEntryView struct {
	CreatedAt  string
	Action     string
	TargetType string
	TargetID   string
	Details    string
}

type betreiberAuditLogData struct {
	Title      string
	Nav        navData
	Entries    []betreiberAuditEntryView
	Suche      string
	Pagination pagination
}

// auditLogFetchLimit begrenzt, wie viele der neuesten Einträge aus der
// DB geholt werden, bevor im Go-Code gefiltert/paginiert wird — echte
// DB-seitige Offset-Paginierung wäre für ein potenziell sehr groß
// werdendes Audit-Log der sauberere Ansatz, ist hier aber (noch) nicht
// umgesetzt (siehe CLAUDE.md, Offene Punkte).
const auditLogFetchLimit = 1000

// handleBetreiberAuditLog zeigt das plattformweite Audit-Log.
func (s *Server) handleBetreiberAuditLog(w http.ResponseWriter, r *http.Request) {
	entries, err := s.store.ListAuditLog(r.Context(), auditLogFetchLimit)
	if err != nil {
		http.Error(w, "Audit-Log konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
		return
	}
	q := strings.TrimSpace(r.URL.Query().Get("q"))
	var gefiltert []store.AuditEntry
	for _, e := range entries {
		if matchesQuery(q, e.Action, e.TargetType, e.Details) {
			gefiltert = append(gefiltert, e)
		}
	}
	pag := paginationFromRequest(r, len(gefiltert))
	data := betreiberAuditLogData{Title: "Audit-Log", Nav: navFor(r), Suche: q, Pagination: pag}
	for _, e := range paginate(gefiltert, pag) {
		data.Entries = append(data.Entries, betreiberAuditEntryView{
			CreatedAt: e.CreatedAt.Format("02.01.2006 15:04:05"), Action: e.Action,
			TargetType: e.TargetType, TargetID: e.TargetID, Details: e.Details,
		})
	}
	if err := s.templates.ExecuteTemplate(w, "betreiber-audit-log", data); err != nil {
		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
	}
}

// handleBetreiberLoginAls meldet den Betreiber als einen bestimmten
// Kunden-Nutzer an (Support-Login) — ohne dessen Passwort zu kennen.
// Nur für aktive Nutzer möglich (ein deaktivierter Login soll auch per
// Support-Zugriff nicht nutzbar sein). Die neue Sitzung ersetzt die
// eigene Betreiber-Sitzung (kein Sitzungs-Stack) — der Betreiber meldet
// sich danach mit den eigenen Zugangsdaten wieder an, das ist für die
// seltene Nutzung dieser Funktion einfacher als ein "Zurück zum
// Betreiber"-Mechanismus. Jede Nutzung wird append-only im Audit-Log
// festgehalten (Actor = Betreiber, Target = der Kunden-Nutzer) und die
// entstehende Sitzung trägt den Betreiber als ImpersonatedByUserID —
// die Nav zeigt während der gesamten Sitzung einen auffälligen Hinweis
// (siehe currentImpersonator, layout.html), damit nie unklar ist, dass
// gerade im Kontext eines fremden Kontos gehandelt wird.
func (s *Server) handleBetreiberLoginAls(w http.ResponseWriter, r *http.Request) {
	betreiber := currentUser(r)
	ziel, err := s.store.GetUser(r.Context(), r.PathValue("userID"))
	if err != nil || ziel.AccountID != r.PathValue("accountID") {
		http.Error(w, "Nutzer nicht gefunden", http.StatusNotFound)
		return
	}
	if !ziel.Active {
		http.Error(w, "Nutzer ist deaktiviert", http.StatusBadRequest)
		return
	}

	token, err := auth.NewSessionToken()
	if err != nil {
		http.Error(w, "Sitzung konnte nicht erzeugt werden: "+err.Error(), http.StatusInternalServerError)
		return
	}
	expiresAt := time.Now().Add(auth.SessionDuration)
	if _, err := s.store.CreateImpersonatedSession(r.Context(), token, ziel.ID, betreiber.ID, expiresAt); err != nil {
		http.Error(w, "Sitzung konnte nicht erzeugt werden: "+err.Error(), http.StatusInternalServerError)
		return
	}
	if _, err := s.store.CreateAuditEntry(r.Context(), betreiber.ID, "betreiber_login_als_nutzer", "app_user", ziel.ID, ziel.Email); err != nil {
		http.Error(w, "Audit-Log konnte nicht geschrieben werden: "+err.Error(), http.StatusInternalServerError)
		return
	}
	setSessionCookie(w, r, token, expiresAt)
	http.Redirect(w, r, "/", http.StatusSeeOther)
}