package userdict
|
|
import (
|
"encoding/json"
|
"fmt"
|
"os"
|
"sort"
|
"strings"
|
"sync"
|
"time"
|
"voicesnap/internal/logger"
|
"voicesnap/internal/paths"
|
)
|
|
// Entry describes one user dictionary replacement rule.
|
type Entry struct {
|
ID int64 `json:"id"`
|
From string `json:"from"`
|
To string `json:"to"`
|
Enabled bool `json:"enabled"`
|
CreatedAt int64 `json:"createdAt"`
|
UpdatedAt int64 `json:"updatedAt"`
|
}
|
|
type fileData struct {
|
Replacements []Entry `json:"replacements"`
|
}
|
|
type exportEntry struct {
|
From string `json:"from"`
|
To string `json:"to"`
|
}
|
|
type exportData struct {
|
Replacements []exportEntry `json:"replacements"`
|
}
|
|
type importEntry struct {
|
ID int64 `json:"id,omitempty"`
|
From string `json:"from"`
|
To string `json:"to"`
|
Enabled *bool `json:"enabled,omitempty"`
|
CreatedAt int64 `json:"createdAt,omitempty"`
|
UpdatedAt int64 `json:"updatedAt,omitempty"`
|
}
|
|
type importData struct {
|
Replacements []importEntry `json:"replacements"`
|
}
|
|
// Store manages user dictionary rules persisted in userdict.json.
|
type Store struct {
|
mu sync.RWMutex
|
entries []Entry
|
path string
|
}
|
|
// New creates a user dictionary store and creates userdict.json if needed.
|
func New() *Store {
|
s := &Store{
|
path: userDictPath(),
|
}
|
s.load()
|
s.save()
|
return s
|
}
|
|
func userDictPath() string {
|
return paths.File("userdict.json")
|
}
|
|
// Path returns the backing JSON file path.
|
func (s *Store) Path() string {
|
return s.path
|
}
|
|
// GetAll returns all dictionary entries newest first for display.
|
func (s *Store) GetAll() []Entry {
|
s.mu.RLock()
|
defer s.mu.RUnlock()
|
|
result := make([]Entry, len(s.entries))
|
copy(result, s.entries)
|
sort.SliceStable(result, func(i, j int) bool {
|
if result[i].CreatedAt == result[j].CreatedAt {
|
return result[i].ID > result[j].ID
|
}
|
return result[i].CreatedAt > result[j].CreatedAt
|
})
|
return result
|
}
|
|
// Add creates a new enabled replacement rule.
|
func (s *Store) Add(from, to string) (Entry, error) {
|
from = strings.TrimSpace(from)
|
to = strings.TrimSpace(to)
|
if from == "" {
|
return Entry{}, fmt.Errorf("source text is required")
|
}
|
|
now := time.Now().UnixMilli()
|
entry := Entry{
|
ID: now,
|
From: from,
|
To: to,
|
Enabled: true,
|
CreatedAt: now,
|
UpdatedAt: now,
|
}
|
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
for s.hasIDLocked(entry.ID) {
|
entry.ID++
|
}
|
s.entries = append(s.entries, entry)
|
s.saveLocked()
|
return entry, nil
|
}
|
|
// Update modifies an existing replacement rule.
|
func (s *Store) Update(id int64, from, to string, enabled bool) (Entry, error) {
|
from = strings.TrimSpace(from)
|
to = strings.TrimSpace(to)
|
if from == "" {
|
return Entry{}, fmt.Errorf("source text is required")
|
}
|
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
for i := range s.entries {
|
if s.entries[i].ID == id {
|
s.entries[i].From = from
|
s.entries[i].To = to
|
s.entries[i].Enabled = enabled
|
s.entries[i].UpdatedAt = time.Now().UnixMilli()
|
s.saveLocked()
|
return s.entries[i], nil
|
}
|
}
|
return Entry{}, fmt.Errorf("entry not found")
|
}
|
|
// Delete removes one entry by id.
|
func (s *Store) Delete(id int64) {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
for i, entry := range s.entries {
|
if entry.ID == id {
|
s.entries = append(s.entries[:i], s.entries[i+1:]...)
|
s.saveLocked()
|
return
|
}
|
}
|
}
|
|
// ClearAll removes all entries.
|
func (s *Store) ClearAll() {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
s.entries = nil
|
s.saveLocked()
|
}
|
|
// Apply replaces text using all enabled user dictionary rules.
|
func (s *Store) Apply(text string) string {
|
if text == "" {
|
return text
|
}
|
|
s.mu.RLock()
|
entries := make([]Entry, len(s.entries))
|
copy(entries, s.entries)
|
s.mu.RUnlock()
|
|
for _, entry := range entries {
|
if !entry.Enabled || entry.From == "" {
|
continue
|
}
|
text = strings.ReplaceAll(text, entry.From, entry.To)
|
}
|
return text
|
}
|
|
// ExportJSON returns the dictionary file contents as formatted JSON.
|
func (s *Store) ExportJSON() string {
|
s.mu.RLock()
|
defer s.mu.RUnlock()
|
|
replacements := make([]exportEntry, 0, len(s.entries))
|
for _, entry := range s.entries {
|
replacements = append(replacements, exportEntry{
|
From: entry.From,
|
To: entry.To,
|
})
|
}
|
|
data, err := json.MarshalIndent(exportData{Replacements: replacements}, "", " ")
|
if err != nil {
|
logger.Error("Failed to export user dictionary: %v", err)
|
return "{\n \"replacements\": []\n}"
|
}
|
return string(data)
|
}
|
|
// ImportJSON replaces the dictionary with entries from JSON.
|
func (s *Store) ImportJSON(content string) error {
|
var fd importData
|
if err := json.Unmarshal([]byte(content), &fd); err != nil {
|
return err
|
}
|
|
now := time.Now().UnixMilli()
|
seen := map[int64]bool{}
|
entries := make([]Entry, 0, len(fd.Replacements))
|
for i := range fd.Replacements {
|
imported := fd.Replacements[i]
|
from := strings.TrimSpace(imported.From)
|
to := strings.TrimSpace(imported.To)
|
if from == "" {
|
return fmt.Errorf("entry %d source text is required", i+1)
|
}
|
id := imported.ID
|
if id <= 0 || seen[id] {
|
id = now + int64(i)
|
}
|
seen[id] = true
|
|
enabled := true
|
if imported.Enabled != nil {
|
enabled = *imported.Enabled
|
}
|
|
createdAt := imported.CreatedAt
|
if createdAt <= 0 {
|
createdAt = now
|
}
|
|
entries = append(entries, Entry{
|
ID: id,
|
From: from,
|
To: to,
|
Enabled: enabled,
|
CreatedAt: createdAt,
|
UpdatedAt: now,
|
})
|
}
|
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
s.entries = entries
|
s.saveLocked()
|
return nil
|
}
|
|
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 user dictionary: %v", err)
|
return
|
}
|
s.entries = fd.Replacements
|
}
|
|
func (s *Store) save() {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
s.saveLocked()
|
}
|
|
func (s *Store) saveLocked() {
|
if err := paths.Ensure(); err != nil {
|
logger.Error("Failed to create app data dir: %v", err)
|
return
|
}
|
|
data, err := json.MarshalIndent(fileData{Replacements: s.entries}, "", " ")
|
if err != nil {
|
logger.Error("Failed to marshal user dictionary: %v", err)
|
return
|
}
|
if err := os.WriteFile(s.path, data, 0644); err != nil {
|
logger.Error("Failed to save user dictionary: %v", err)
|
}
|
}
|
|
func (s *Store) hasIDLocked(id int64) bool {
|
for _, entry := range s.entries {
|
if entry.ID == id {
|
return true
|
}
|
}
|
return false
|
}
|
