package history
|
|
import (
|
"encoding/json"
|
"fmt"
|
"os"
|
"path/filepath"
|
"sync"
|
"time"
|
"unicode/utf8"
|
"voicesnap/internal/logger"
|
"voicesnap/internal/paths"
|
)
|
|
const defaultRetentionDays = 30
|
const defaultPageSize = 100
|
const maxPageSize = 500
|
|
// Entry represents a single recognition history item.
|
type Entry struct {
|
Text string `json:"text"`
|
Timestamp int64 `json:"timestamp"` // Unix milliseconds
|
ExportedAt int64 `json:"exportedAt,omitempty"` // Unix milliseconds; 0 means unexported
|
}
|
|
// ExportScope limits which unexported entries are returned for correction CSV export.
|
type ExportScope string
|
|
const (
|
ExportScopeToday ExportScope = "today"
|
ExportScopeLast7Days ExportScope = "last7Days"
|
ExportScopeAll ExportScope = "all"
|
)
|
|
// Store manages recognition history with JSON file persistence.
|
type Store struct {
|
mu sync.Mutex
|
entries []Entry
|
retentionDays int
|
path string
|
}
|
|
type fileData struct {
|
RetentionDays *int `json:"retentionDays"`
|
Entries []Entry `json:"entries"`
|
}
|
|
// PageResult contains one page of history entries plus pagination metadata.
|
type PageResult struct {
|
Entries []Entry `json:"entries"`
|
Total int `json:"total"`
|
Page int `json:"page"`
|
PageSize int `json:"pageSize"`
|
TotalPages int `json:"totalPages"`
|
}
|
|
// Counts summarizes history state across the full retained dataset.
|
type Counts struct {
|
TotalCount int `json:"totalCount"`
|
ExportedCount int `json:"exportedCount"`
|
UnexportedTodayCount int `json:"unexportedTodayCount"`
|
UnexportedLast7DaysCount int `json:"unexportedLast7DaysCount"`
|
UnexportedAllCount int `json:"unexportedAllCount"`
|
}
|
|
// ClearExportedResult reports how many exported entries were removed.
|
type ClearExportedResult struct {
|
DeletedCount int `json:"deletedCount"`
|
RemainingCount int `json:"remainingCount"`
|
}
|
|
// New creates a new history store, loading existing data from disk.
|
func New() *Store {
|
s := &Store{
|
retentionDays: defaultRetentionDays,
|
path: historyPath(),
|
}
|
s.load()
|
s.pruneAndSave()
|
return s
|
}
|
|
// Add inserts a new entry at the top and persists to disk.
|
// Single-character results (e.g. "." "。") are noise and skipped.
|
func (s *Store) Add(text string) {
|
if utf8.RuneCountInString(text) <= 1 {
|
return
|
}
|
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
entry := Entry{
|
Text: text,
|
Timestamp: time.Now().UnixMilli(),
|
}
|
|
// Prepend
|
s.entries = append([]Entry{entry}, s.entries...)
|
s.pruneUnlocked()
|
|
s.save()
|
}
|
|
// GetAll returns all history entries (newest first).
|
func (s *Store) GetAll() []Entry {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
if s.pruneUnlocked() {
|
s.save()
|
}
|
|
result := make([]Entry, len(s.entries))
|
copy(result, s.entries)
|
return result
|
}
|
|
// GetPage returns a clamped page of history entries (newest first).
|
func (s *Store) GetPage(page int, pageSize int) PageResult {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
if s.pruneUnlocked() {
|
s.save()
|
}
|
|
pageSize = normalizePageSize(pageSize)
|
total := len(s.entries)
|
totalPages := 0
|
if total > 0 {
|
totalPages = (total + pageSize - 1) / pageSize
|
}
|
page = normalizePage(page, totalPages)
|
|
result := PageResult{
|
Total: total,
|
Page: page,
|
PageSize: pageSize,
|
TotalPages: totalPages,
|
Entries: []Entry{},
|
}
|
if total == 0 {
|
return result
|
}
|
|
start := (page - 1) * pageSize
|
if start >= total {
|
start = 0
|
result.Page = 1
|
}
|
end := start + pageSize
|
if end > total {
|
end = total
|
}
|
result.Entries = make([]Entry, end-start)
|
copy(result.Entries, s.entries[start:end])
|
return result
|
}
|
|
// Counts returns full-history counters used by paginated frontends.
|
func (s *Store) Counts(now time.Time, loc *time.Location) Counts {
|
if loc == nil {
|
loc = time.Local
|
}
|
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
if s.pruneUnlocked() {
|
s.save()
|
}
|
|
todayCutoff := exportScopeCutoff(ExportScopeToday, now, loc)
|
last7DaysCutoff := exportScopeCutoff(ExportScopeLast7Days, now, loc)
|
counts := Counts{TotalCount: len(s.entries)}
|
for _, entry := range s.entries {
|
if entry.ExportedAt > 0 {
|
counts.ExportedCount++
|
continue
|
}
|
counts.UnexportedAllCount++
|
if entry.Timestamp >= todayCutoff {
|
counts.UnexportedTodayCount++
|
}
|
if entry.Timestamp >= last7DaysCutoff {
|
counts.UnexportedLast7DaysCount++
|
}
|
}
|
return counts
|
}
|
|
// GetUnexported returns unexported history entries within the requested export scope.
|
func (s *Store) GetUnexported(scope ExportScope, now time.Time, loc *time.Location) []Entry {
|
if loc == nil {
|
loc = time.Local
|
}
|
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
if s.pruneUnlocked() {
|
s.save()
|
}
|
|
cutoff := exportScopeCutoff(scope, now, loc)
|
result := make([]Entry, 0, len(s.entries))
|
for _, entry := range s.entries {
|
if entry.ExportedAt > 0 {
|
continue
|
}
|
if cutoff > 0 && entry.Timestamp < cutoff {
|
continue
|
}
|
result = append(result, entry)
|
}
|
return result
|
}
|
|
// MarkExported marks entries as exported after a correction CSV has been written successfully.
|
func (s *Store) MarkExported(timestamps []int64, exportedAt int64) (int, error) {
|
if len(timestamps) == 0 {
|
return 0, nil
|
}
|
if exportedAt <= 0 {
|
exportedAt = time.Now().UnixMilli()
|
}
|
|
targets := make(map[int64]struct{}, len(timestamps))
|
for _, timestamp := range timestamps {
|
targets[timestamp] = struct{}{}
|
}
|
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
updated := 0
|
previous := map[int]int64{}
|
for i := range s.entries {
|
if _, ok := targets[s.entries[i].Timestamp]; !ok {
|
continue
|
}
|
if s.entries[i].ExportedAt > 0 {
|
continue
|
}
|
previous[i] = s.entries[i].ExportedAt
|
s.entries[i].ExportedAt = exportedAt
|
updated++
|
}
|
if updated > 0 {
|
if err := s.save(); err != nil {
|
for index, value := range previous {
|
s.entries[index].ExportedAt = value
|
}
|
return 0, err
|
}
|
}
|
return updated, nil
|
}
|
|
// Delete removes an entry by its timestamp.
|
func (s *Store) Delete(timestamp int64) {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
for i, e := range s.entries {
|
if e.Timestamp == timestamp {
|
s.entries = append(s.entries[:i], s.entries[i+1:]...)
|
s.save()
|
return
|
}
|
}
|
}
|
|
// ClearAll removes all entries.
|
func (s *Store) ClearAll() {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
s.entries = nil
|
s.save()
|
}
|
|
// ClearExported removes all entries that have been successfully exported.
|
func (s *Store) ClearExported() (ClearExportedResult, error) {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
previous := make([]Entry, len(s.entries))
|
copy(previous, s.entries)
|
|
kept := s.entries[:0]
|
deleted := 0
|
for _, entry := range s.entries {
|
if entry.ExportedAt > 0 {
|
deleted++
|
continue
|
}
|
kept = append(kept, entry)
|
}
|
if deleted == 0 {
|
return ClearExportedResult{DeletedCount: 0, RemainingCount: len(s.entries)}, nil
|
}
|
|
s.entries = kept
|
if err := s.save(); err != nil {
|
s.entries = previous
|
return ClearExportedResult{}, err
|
}
|
return ClearExportedResult{DeletedCount: deleted, RemainingCount: len(s.entries)}, nil
|
}
|
|
// GetRetentionDays returns the current retention period.
|
func (s *Store) GetRetentionDays() int {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
return s.retentionDays
|
}
|
|
// SetRetentionDays sets the retention period and prunes old entries.
|
func (s *Store) SetRetentionDays(days int) error {
|
if !validRetentionDays(days) {
|
return fmt.Errorf("unsupported history retention days: %d", days)
|
}
|
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
s.retentionDays = days
|
s.pruneUnlocked()
|
s.save()
|
return nil
|
}
|
|
// Path returns the persisted history file path.
|
func (s *Store) Path() string {
|
return s.path
|
}
|
|
// prune removes entries older than the retention period.
|
func (s *Store) pruneAndSave() {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
if s.pruneUnlocked() {
|
s.save()
|
}
|
}
|
|
func (s *Store) pruneUnlocked() bool {
|
if s.retentionDays <= 0 {
|
return false // 0 = keep forever
|
}
|
|
before := len(s.entries)
|
cutoff := time.Now().Add(-time.Duration(s.retentionDays) * 24 * time.Hour).UnixMilli()
|
kept := s.entries[:0]
|
for _, e := range s.entries {
|
if e.Timestamp >= cutoff {
|
kept = append(kept, e)
|
}
|
}
|
s.entries = kept
|
return len(s.entries) != before
|
}
|
|
func (s *Store) load() {
|
data, err := os.ReadFile(s.path)
|
if err != nil {
|
return
|
}
|
|
var fd fileData
|
if err := json.Unmarshal(data, &fd); err != nil {
|
logger.Error("Failed to parse history: %v", err)
|
return
|
}
|
|
s.entries = fd.Entries
|
if fd.RetentionDays != nil {
|
s.retentionDays = normalizeRetentionDays(*fd.RetentionDays)
|
}
|
}
|
|
func (s *Store) save() error {
|
if err := os.MkdirAll(filepath.Dir(s.path), 0755); err != nil {
|
logger.Error("Failed to create history dir: %v", err)
|
return err
|
}
|
|
days := s.retentionDays
|
fd := fileData{
|
RetentionDays: &days,
|
Entries: s.entries,
|
}
|
|
data, err := json.MarshalIndent(fd, "", " ")
|
if err != nil {
|
logger.Error("Failed to marshal history: %v", err)
|
return err
|
}
|
|
if err := os.WriteFile(s.path, data, 0600); err != nil {
|
logger.Error("Failed to save history: %v", err)
|
return err
|
}
|
if err := os.Chmod(s.path, 0600); err != nil {
|
logger.Error("Failed to set history permissions: %v", err)
|
return err
|
}
|
return nil
|
}
|
|
func historyPath() string {
|
return paths.File("history.json")
|
}
|
|
func normalizeRetentionDays(days int) int {
|
if validRetentionDays(days) {
|
return days
|
}
|
return defaultRetentionDays
|
}
|
|
func validRetentionDays(days int) bool {
|
switch days {
|
case 0, 7, 30, 90:
|
return true
|
default:
|
return false
|
}
|
}
|
|
func normalizePageSize(pageSize int) int {
|
if pageSize <= 0 {
|
return defaultPageSize
|
}
|
if pageSize > maxPageSize {
|
return maxPageSize
|
}
|
return pageSize
|
}
|
|
func normalizePage(page int, totalPages int) int {
|
if totalPages <= 0 {
|
return 1
|
}
|
if page < 1 {
|
return 1
|
}
|
if page > totalPages {
|
return totalPages
|
}
|
return page
|
}
|
|
// ParseExportScope normalizes frontend export scope values.
|
func ParseExportScope(value string) (ExportScope, error) {
|
scope := ExportScope(value)
|
switch scope {
|
case "", ExportScopeAll:
|
return ExportScopeAll, nil
|
case ExportScopeToday, ExportScopeLast7Days:
|
return scope, nil
|
default:
|
return "", fmt.Errorf("unsupported history export scope: %s", value)
|
}
|
}
|
|
func exportScopeCutoff(scope ExportScope, now time.Time, loc *time.Location) int64 {
|
switch scope {
|
case ExportScopeToday:
|
localNow := now.In(loc)
|
year, month, day := localNow.Date()
|
return time.Date(year, month, day, 0, 0, 0, 0, loc).UnixMilli()
|
case ExportScopeLast7Days:
|
return now.In(loc).AddDate(0, 0, -7).UnixMilli()
|
default:
|
return 0
|
}
|
}
|
