// Package logbuffer maintient un tampon circulaire en mémoire des lignes de log.
// Il implémente io.Writer pour être branché sur log.SetOutput via io.MultiWriter.
package logbuffer

import (
	"bytes"
	"sync"
)

const maxLines = 500

// Buffer est un tampon circulaire thread-safe de lignes de log.
type Buffer struct {
	mu    sync.RWMutex
	lines []string
}

// Write implémente io.Writer. Découpe p en lignes et les ajoute au tampon.
func (b *Buffer) Write(p []byte) (int, error) {
	b.mu.Lock()
	defer b.mu.Unlock()

	for _, line := range bytes.Split(p, []byte("\n")) {
		s := string(bytes.TrimRight(line, "\r"))
		if s == "" {
			continue
		}
		b.lines = append(b.lines, s)
		if len(b.lines) > maxLines {
			b.lines = b.lines[len(b.lines)-maxLines:]
		}
	}
	return len(p), nil
}

// Lines retourne les n dernières lignes (ou toutes si n <= 0 ou n > taille).
func (b *Buffer) Lines(n int) []string {
	b.mu.RLock()
	defer b.mu.RUnlock()

	total := len(b.lines)
	if n <= 0 || n >= total {
		result := make([]string, total)
		copy(result, b.lines)
		return result
	}
	result := make([]string, n)
	copy(result, b.lines[total-n:])
	return result
}

// Global est l'instance partagée utilisée par main.go et les handlers.
var Global = &Buffer{}
