package history

import (
	"encoding/json"
	"os"
	"sync"
	"time"
	"unicode/utf8"
	"voicesnap/internal/logger"
	"voicesnap/internal/paths"
)

const maxEntries = 50

// Entry represents a single recognition history item.
type Entry struct {
	Text      string `json:"text"`
	Timestamp int64  `json:"timestamp"` // Unix milliseconds
}

// 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"`
}

// New creates a new history store, loading existing data from disk.
func New() *Store {
	s := &Store{
		retentionDays: 30,
		path:          historyPath(),
	}
	s.load()
	s.prune()
	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...)

	// Cap at max
	if len(s.entries) > maxEntries {
		s.entries = s.entries[:maxEntries]
	}

	s.save()
}

// GetAll returns all history entries (newest first).
func (s *Store) GetAll() []Entry {
	s.mu.Lock()
	defer s.mu.Unlock()

	result := make([]Entry, len(s.entries))
	copy(result, s.entries)
	return result
}

// 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()
}

// 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) {
	s.mu.Lock()
	defer s.mu.Unlock()

	s.retentionDays = days
	s.pruneUnlocked()
	s.save()
}

// prune removes entries older than the retention period.
func (s *Store) prune() {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.pruneUnlocked()
}

func (s *Store) pruneUnlocked() {
	if s.retentionDays <= 0 {
		return // 0 = keep forever
	}

	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
}

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 = *fd.RetentionDays
	}
}

func (s *Store) save() {
	if err := paths.Ensure(); err != nil {
		logger.Error("Failed to create app data dir: %v", err)
		return
	}

	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
	}

	if err := os.WriteFile(s.path, data, 0644); err != nil {
		logger.Error("Failed to save history: %v", err)
	}
}

func historyPath() string {
	return paths.File("history.json")
}