converter

type BasicUnitConverter struct {
	// contains filtered or unexported fields
}

type CodeBlock struct {
	Start    int    // Start position in original text
	End      int    // End position in original text
	Language string // Detected language (if any)
	Content  string // Raw content of the code block
	IsCode   bool   // true if this is code, false if it's regular text
}

type CommentBlock struct {
	Start   int    // Start position in code
	End     int    // End position in code
	Content string // Comment text
}

type ContextAwareWordDetector struct {
	// contains filtered or unexported fields
}

type ContextualMapping struct {
	BaseWord        string             `json:"baseWord"`        // The base American word (e.g., "license")
	NounReplacement string             `json:"nounReplacement"` // British spelling when used as noun (e.g., "licence")
	VerbReplacement string             `json:"verbReplacement"` // British spelling when used as verb (e.g., "license")
	Confidence      map[string]float64 `json:"confidence"`      // Confidence overrides for different contexts
}

type ContextualUnitDetector struct {
	// contains filtered or unexported fields
}

type ContextualWordConfig struct {
	// Global enable/disable flag
	Enabled bool `json:"enabled"`

	// Word configurations by base word
	WordConfigs map[string]WordConfig `json:"wordConfigs"`

	// Minimum confidence threshold for contextual detection (0.0 - 1.0)
	MinConfidence float64 `json:"minConfidence"`

	// Custom exclusion patterns (regex patterns to avoid conversion)
	ExcludePatterns []string `json:"excludePatterns"`

	// Conversion preferences
	Preferences ContextualWordPreferences `json:"preferences"`

	// Backward compatibility fields
	SupportedWords []string                     `json:"-"` // Populated dynamically
	CustomMappings map[string]ContextualMapping `json:"-"` // Populated dynamically
}

type ContextualWordDetector interface {
	DetectWords(text string) []ContextualWordMatch
	SupportedWords() []string
	SetMinConfidence(confidence float64)
	SetEnabled(enabled bool)
	IsEnabled() bool
}

type ContextualWordMatch struct {
	Start        int      // Start position in text
	End          int      // End position in text
	OriginalWord string   // The original word found
	WordType     WordType // Detected grammatical role
	Replacement  string   // The contextually appropriate replacement
	Confidence   float64  // Confidence score for this match (0.0-1.0)
	Context      string   // Surrounding context used for detection
	BaseWord     string   // The base word this match relates to
}

type ContextualWordPattern struct {
	Pattern     *regexp.Regexp // Regex pattern to match the word in context
	WordType    WordType       // The grammatical role this pattern detects
	BaseWord    string         // The base word this pattern applies to (e.g., "license")
	Replacement string         // The appropriate spelling for this context (e.g., "licence" for noun)
	Confidence  float64        // Base confidence for this pattern (0.0-1.0)
	Description string         // Human-readable description of this pattern
}

type ContextualWordPatterns struct {
	// Word configurations by base word
	WordConfigs map[string]WordConfig

	// Generated patterns by base word
	GeneratedPatterns map[string][]ContextualWordPattern

	// Exclusion patterns for ambiguous or problematic contexts
	ExclusionPatterns []*regexp.Regexp

	// General pattern templates
	GeneralPatterns []GeneralPattern
}

type ContextualWordPreferences struct {
	// Whether to prefer noun conversion when context is ambiguous
	PreferNounOnAmbiguity bool `json:"preferNounOnAmbiguity"`

	// Whether to fall back to regular dictionary when contextual conversion fails
	FallbackToDictionary bool `json:"fallbackToDictionary"`

	// Whether to show warnings for ambiguous contexts
	ShowAmbiguityWarnings bool `json:"showAmbiguityWarnings"`

	// Case sensitivity for pattern matching
	CaseSensitive bool `json:"caseSensitive"`

	// Whether to convert within quoted strings
	ConvertQuotedText bool `json:"convertQuotedText"`
}

type ConversionPreferences struct {
	PreferWholeNumbers          bool
	MaxDecimalPlaces            int
	UseLocalizedUnits           bool
	TemperatureFormat           string  // "°C" or "degrees Celsius"
	UseSpaceBetweenValueAndUnit bool    // true: "5 kg", false: "5kg"
	RoundingThreshold           float64 // threshold for considering a value "close to whole" (default: 0.05)
}

type ConversionResult struct {
	MetricValue float64
	MetricUnit  string
	Formatted   string
	Confidence  float64
}

type Converter struct {
	// contains filtered or unexported fields
}

type DetectionConfig struct {
	// Minimum confidence threshold for unit detection (0.0 - 1.0)
	MinConfidence float64 `json:"minConfidence"`

	// Maximum distance between number and unit (in words)
	MaxNumberDistance int `json:"maxNumberDistance"`

	// Whether to detect compound units (e.g., "6-foot")
	DetectCompoundUnits bool `json:"detectCompoundUnits"`

	// Whether to detect written numbers (e.g., "five feet")
	DetectWrittenNumbers bool `json:"detectWrittenNumbers"`
}

type Dictionaries struct {
	AmericanToBritish map[string]string
}

type GeneralPattern struct {
	Name       string   // Pattern identifier
	Template   string   // Pattern template with {WORD} placeholder
	TargetType WordType // The grammatical role this pattern detects
	Confidence float64  // Base confidence for this pattern (0.0-1.0)
}

type SentenceAwareConverter struct {
	// contains filtered or unexported fields
}

type TextPart struct {
	Content   string
	IsCode    bool
	Language  string
	FenceType string // "“`" or "~~~" for fenced code blocks
}

type TextSegment struct {
	Content  string
	IsCode   bool
	Language string
}

type UnitConfig struct {
	// Global enable/disable flag
	Enabled bool `json:"enabled"`

	// Unit type specific settings
	EnabledUnitTypes []UnitType `json:"enabledUnitTypes"`

	// Precision settings for each unit type
	Precision map[string]int `json:"precision"`

	// Custom unit mappings (American -> British)
	CustomMappings map[string]string `json:"customMappings"`

	// Patterns to exclude from conversion (regex patterns)
	ExcludePatterns []string `json:"excludePatterns"`

	// Conversion preferences
	Preferences ConversionPreferences `json:"preferences"`

	// Detection settings
	Detection DetectionConfig `json:"detection"`
}

type UnitConverter interface {
	Convert(match UnitMatch) (ConversionResult, error)
	SetPrecision(unitType UnitType, precision int)
	SetPreferences(prefs ConversionPreferences)
}

type UnitDetector interface {
	DetectUnits(text string) []UnitMatch
	SupportedUnits() []UnitType
}

type UnitMatch struct {
	Start      int
	End        int
	Value      float64
	Unit       string
	UnitType   UnitType
	Context    string
	Confidence float64
	IsCompound bool // true if this is a compound unit like "6-foot"
}

type UnitPattern struct {
	Pattern    *regexp.Regexp
	UnitType   UnitType
	UnitNames  []string // Possible unit names this pattern can match
	Confidence float64  // Base confidence for this pattern
}

type UnitPatterns struct {
	// Positive patterns for detecting measurements
	LengthPatterns      []UnitPattern
	MassPatterns        []UnitPattern
	VolumePatterns      []UnitPattern
	TemperaturePatterns []UnitPattern
	AreaPatterns        []UnitPattern

	// Negative patterns for excluding idiomatic usage
	ExclusionPatterns []*regexp.Regexp
}

type UnitProcessor struct {
	// contains filtered or unexported fields
}

type UnitType int

type WordConfig struct {
	Noun    string `json:"noun"`    // British spelling when used as noun
	Verb    string `json:"verb"`    // British spelling when used as verb
	Enabled bool   `json:"enabled"` // Whether this word pair is enabled
}

type WordType int