///|
/// Reusable immutable configuration for common toolkit operations.
pub struct PinyinProcessor {
  lexicon_value : Lexicon
  conversion_value : ConvertOptions
  fuzzy_value : FuzzyProfile
}

///|
pub fn pinyin_processor(
  lexicon : Lexicon,
  options : ConvertOptions,
  fuzzy : FuzzyProfile,
) -> PinyinProcessor {
  { lexicon_value: lexicon, conversion_value: options, fuzzy_value: fuzzy }
}

///|
pub fn default_pinyin_processor() -> PinyinProcessor {
  pinyin_processor(
    LexiconBuilder::new().build(),
    default_convert_options(),
    default_fuzzy_profile(),
  )
}

///|
pub fn PinyinProcessor::convert(
  self : PinyinProcessor,
  source : String,
) -> Result[ConversionResult, PinyinError] {
  convert_text(source, self.lexicon_value, self.conversion_value)
}

///|
pub fn PinyinProcessor::inspect(
  self : PinyinProcessor,
  source : String,
) -> ReadingInspection {
  let _ = self
  inspect_text_readings(source)
}

///|
pub fn PinyinProcessor::compare(
  self : PinyinProcessor,
  left : String,
  right : String,
) -> Result[TextComparison, PinyinError] {
  compare_texts(
    left,
    right,
    self.lexicon_value,
    self.conversion_value,
    self.fuzzy_value,
  )
}

///|
pub fn PinyinProcessor::candidate(
  self : PinyinProcessor,
  identifier : String,
  source : String,
) -> Result[MatchCandidate, PinyinError] {
  match self.convert(source) {
    Err(error) => Err(error)
    Ok(converted) => Ok(match_candidate(identifier, converted))
  }
}

///|
pub fn PinyinProcessor::variants(
  self : PinyinProcessor,
  source : String,
  style : ToneStyle,
  separator : String,
  limit : Int,
) -> Result[VariantExpansion, PinyinError] {
  let converted = match self.convert(source) {
    Err(error) => return Err(error)
    Ok(value) => value
  }
  expand_conversion_variants(converted, style, separator, limit)
}

///|
pub fn PinyinProcessor::conversion_options(
  self : PinyinProcessor,
) -> ConvertOptions {
  self.conversion_value
}

///|
pub fn PinyinProcessor::fuzzy_profile(self : PinyinProcessor) -> FuzzyProfile {
  self.fuzzy_value
}