package userdict
|
|
import (
|
"encoding/json"
|
"fmt"
|
"os"
|
"path/filepath"
|
"sort"
|
"strings"
|
"sync"
|
"time"
|
"voicesnap/internal/logger"
|
"voicesnap/internal/paths"
|
)
|
|
const defaultPageSize = 100
|
const maxPageSize = 500
|
|
// 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"`
|
}
|
|
// Replacement is a new replacement rule to append to the dictionary.
|
type Replacement struct {
|
From string
|
To string
|
}
|
|
type fileData struct {
|
Replacements []Entry `json:"replacements"`
|
}
|
|
type storedEntry 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 storedFileData struct {
|
Replacements []storedEntry `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"`
|
}
|
|
// PageResult contains one page of dictionary 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"`
|
}
|
|
// 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()
|
if err := s.save(); err != nil {
|
logger.Error("Failed to initialize user dictionary: %v", err)
|
}
|
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()
|
|
return sortedEntries(s.entries)
|
}
|
|
// GetPage returns a clamped page of dictionary entries newest first.
|
func (s *Store) GetPage(page int, pageSize int) PageResult {
|
s.mu.RLock()
|
defer s.mu.RUnlock()
|
|
pageSize = normalizePageSize(pageSize)
|
total := len(s.entries)
|
totalPages := 0
|
if total > 0 {
|
totalPages = (total + pageSize - 1) / pageSize
|
}
|
page = normalizePage(page, totalPages)
|
|
result := PageResult{
|
Entries: []Entry{},
|
Total: total,
|
Page: page,
|
PageSize: pageSize,
|
TotalPages: totalPages,
|
}
|
if total == 0 {
|
return result
|
}
|
|
sorted := sortedEntries(s.entries)
|
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, sorted[start:end])
|
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++
|
}
|
entries := append(cloneEntries(s.entries), entry)
|
if err := s.saveEntriesLocked(entries); err != nil {
|
return Entry{}, err
|
}
|
s.entries = entries
|
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 {
|
entries := cloneEntries(s.entries)
|
entries[i].From = from
|
entries[i].To = to
|
entries[i].Enabled = enabled
|
entries[i].UpdatedAt = time.Now().UnixMilli()
|
if err := s.saveEntriesLocked(entries); err != nil {
|
return Entry{}, err
|
}
|
s.entries = entries
|
return entries[i], nil
|
}
|
}
|
return Entry{}, fmt.Errorf("entry not found")
|
}
|
|
// AppendNewReplacements appends enabled replacement rules as one all-or-nothing write.
|
func (s *Store) AppendNewReplacements(rules []Replacement) ([]Entry, error) {
|
now := time.Now().UnixMilli()
|
prepared := make([]Replacement, 0, len(rules))
|
for i, rule := range rules {
|
from := strings.TrimSpace(rule.From)
|
to := strings.TrimSpace(rule.To)
|
if from == "" {
|
return nil, fmt.Errorf("entry %d source text is required", i+1)
|
}
|
prepared = append(prepared, Replacement{From: from, To: to})
|
}
|
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
existingPairs := map[string]struct{}{}
|
existingFrom := map[string]string{}
|
for _, entry := range s.entries {
|
from := strings.TrimSpace(entry.From)
|
to := strings.TrimSpace(entry.To)
|
if from == "" {
|
continue
|
}
|
existingPairs[pairKey(from, to)] = struct{}{}
|
if _, ok := existingFrom[from]; !ok {
|
existingFrom[from] = to
|
}
|
}
|
|
entries := cloneEntries(s.entries)
|
added := make([]Entry, 0, len(prepared))
|
for i, rule := range prepared {
|
if _, ok := existingPairs[pairKey(rule.From, rule.To)]; ok {
|
return nil, fmt.Errorf("dictionary already contains replacement %q", rule.From)
|
}
|
if to, ok := existingFrom[rule.From]; ok && to != rule.To {
|
return nil, fmt.Errorf("dictionary contains conflicting replacement %q", rule.From)
|
}
|
|
id := now + int64(i)
|
for hasID(entries, id) {
|
id++
|
}
|
entry := Entry{
|
ID: id,
|
From: rule.From,
|
To: rule.To,
|
Enabled: true,
|
CreatedAt: now,
|
UpdatedAt: now,
|
}
|
entries = append(entries, entry)
|
added = append(added, entry)
|
existingPairs[pairKey(rule.From, rule.To)] = struct{}{}
|
existingFrom[rule.From] = rule.To
|
}
|
|
if err := s.saveEntriesLocked(entries); err != nil {
|
return nil, err
|
}
|
s.entries = entries
|
return added, nil
|
}
|
|
// 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 {
|
entries := append(cloneEntries(s.entries[:i]), s.entries[i+1:]...)
|
if err := s.saveEntriesLocked(entries); err != nil {
|
logger.Error("Failed to delete user dictionary entry: %v", err)
|
return
|
}
|
s.entries = entries
|
return
|
}
|
}
|
}
|
|
// ClearAll removes all entries.
|
func (s *Store) ClearAll() {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
|
if err := s.saveEntriesLocked(nil); err != nil {
|
logger.Error("Failed to clear user dictionary: %v", err)
|
return
|
}
|
s.entries = nil
|
}
|
|
// 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()
|
|
if err := s.saveEntriesLocked(entries); err != nil {
|
return err
|
}
|
s.entries = entries
|
return nil
|
}
|
|
func (s *Store) load() {
|
data, err := os.ReadFile(s.path)
|
if err != nil {
|
return
|
}
|
|
var fd storedFileData
|
if err := json.Unmarshal(data, &fd); err != nil {
|
logger.Error("Failed to parse user dictionary: %v", err)
|
return
|
}
|
|
now := time.Now().UnixMilli()
|
s.entries = make([]Entry, 0, len(fd.Replacements))
|
seen := map[int64]bool{}
|
for i, stored := range fd.Replacements {
|
from := strings.TrimSpace(stored.From)
|
if from == "" {
|
continue
|
}
|
id := stored.ID
|
if id <= 0 || seen[id] {
|
id = now + int64(i)
|
}
|
seen[id] = true
|
enabled := true
|
if stored.Enabled != nil {
|
enabled = *stored.Enabled
|
}
|
createdAt := stored.CreatedAt
|
if createdAt <= 0 {
|
createdAt = now
|
}
|
updatedAt := stored.UpdatedAt
|
if updatedAt <= 0 {
|
updatedAt = createdAt
|
}
|
s.entries = append(s.entries, Entry{
|
ID: id,
|
From: from,
|
To: strings.TrimSpace(stored.To),
|
Enabled: enabled,
|
CreatedAt: createdAt,
|
UpdatedAt: updatedAt,
|
})
|
}
|
}
|
|
func (s *Store) save() error {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
return s.saveEntriesLocked(s.entries)
|
}
|
|
func (s *Store) saveEntriesLocked(entries []Entry) error {
|
if err := paths.Ensure(); err != nil {
|
logger.Error("Failed to create app data dir: %v", err)
|
return err
|
}
|
|
data, err := json.MarshalIndent(fileData{Replacements: entries}, "", " ")
|
if err != nil {
|
logger.Error("Failed to marshal user dictionary: %v", err)
|
return err
|
}
|
|
dir := filepath.Dir(s.path)
|
temp, err := os.CreateTemp(dir, ".userdict-*.tmp")
|
if err != nil {
|
logger.Error("Failed to create user dictionary temp file: %v", err)
|
return err
|
}
|
tempPath := temp.Name()
|
defer os.Remove(tempPath)
|
|
if _, err := temp.Write(data); err != nil {
|
temp.Close()
|
logger.Error("Failed to write user dictionary temp file: %v", err)
|
return err
|
}
|
if err := temp.Chmod(0600); err != nil {
|
temp.Close()
|
logger.Error("Failed to set user dictionary permissions: %v", err)
|
return err
|
}
|
if err := temp.Close(); err != nil {
|
logger.Error("Failed to close user dictionary temp file: %v", err)
|
return err
|
}
|
if err := os.Rename(tempPath, s.path); err != nil {
|
logger.Error("Failed to save user dictionary: %v", err)
|
return err
|
}
|
return nil
|
}
|
|
func (s *Store) hasIDLocked(id int64) bool {
|
return hasID(s.entries, id)
|
}
|
|
func cloneEntries(entries []Entry) []Entry {
|
cloned := make([]Entry, len(entries))
|
copy(cloned, entries)
|
return cloned
|
}
|
|
func sortedEntries(entries []Entry) []Entry {
|
result := cloneEntries(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
|
}
|
|
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
|
}
|
|
func hasID(entries []Entry, id int64) bool {
|
for _, entry := range entries {
|
if entry.ID == id {
|
return true
|
}
|
}
|
return false
|
}
|
|
func pairKey(from, to string) string {
|
return from + "\x00" + to
|
}
|
