package net.sf.okapi.steps.llmsentencealigner;
   
   import com.acumenvelocity.ath.common.Const;
   
   import net.sf.okapi.common.ParametersDescription;
   import net.sf.okapi.common.StringParameters;
   
   public class LlmSentenceAlignerParameters extends StringParameters {
   
    private static final String ALIGNMENT_MODEL_NAME = "alignmentModelName";
    private static final String MAX_PARAGRAPHS_PER_REQUEST = "maxParagraphsPerRequest";
    private static final String LOG_ALIGNMENT_DETAILS = "logAlignmentDetails";
  
    private static final String SEGMENT_SOURCE = "segmentSource";
    private static final String USE_CUSTOM_SOURCE_RULES = "useCustomSourceRules";
    private static final String CUSTOM_SOURCE_RULES_PATH = "customSourceRulesPath";
    private static final String SEGMENT_TARGET = "segmentTarget";
    private static final String USE_CUSTOM_TARGET_RULES = "useCustomTargetRules";
    private static final String CUSTOM_TARGET_RULES_PATH = "customTargetRulesPath";
    private static final String COLLAPSE_WHITESPACE = "collapseWhitespace";
  
    private static final String USE_CODES_REINSERTION_MODEL = "useCodesReinsertionModel";
    private static final String CODES_REINSERTION_MODEL_NAME = "codesReinsertionModelName";
  
    public String getAlignmentModelName() {
      return getString(ALIGNMENT_MODEL_NAME);
    }
  
    public void setAlignmentModelName(String alignmentModelName) {
      setString(ALIGNMENT_MODEL_NAME, alignmentModelName);
    }
  
    public int getMaxParagraphsPerRequest() {
      return getInteger(MAX_PARAGRAPHS_PER_REQUEST);
    }
  
    public void setMaxParagraphsPerRequest(int maxParagraphsPerRequest) {
      setInteger(MAX_PARAGRAPHS_PER_REQUEST, maxParagraphsPerRequest);
    }
  
    public boolean isLogAlignmentDetails() {
      return getBoolean(LOG_ALIGNMENT_DETAILS);
    }
  
    public void setLogAlignmentDetails(boolean logAlignmentDetails) {
      setBoolean(LOG_ALIGNMENT_DETAILS, logAlignmentDetails);
    }
  
    public boolean isSegmentSource() {
      return getBoolean(SEGMENT_SOURCE);
    }
  
    public void setSegmentSource(boolean segmentSource) {
      setBoolean(SEGMENT_SOURCE, segmentSource);
    }
  
    public boolean isUseCustomSourceRules() {
      return getBoolean(USE_CUSTOM_SOURCE_RULES);
    }
  
    public void setUseCustomSourceRules(boolean useCustomSourceRules) {
      setBoolean(USE_CUSTOM_SOURCE_RULES, useCustomSourceRules);
    }
  
    public String getCustomSourceRulesPath() {
      return getString(CUSTOM_SOURCE_RULES_PATH);
    }
  
    public void setCustomSourceRulesPath(String customSourceRulesPath) {
      setString(CUSTOM_SOURCE_RULES_PATH, customSourceRulesPath);
    }
  
    public boolean isSegmentTarget() {
      return getBoolean(SEGMENT_TARGET);
    }
  
    public void setSegmentTarget(boolean segmentTarget) {
      setBoolean(SEGMENT_TARGET, segmentTarget);
    }
  
    public boolean isUseCustomTargetRules() {
      return getBoolean(USE_CUSTOM_TARGET_RULES);
    }
  
    public void setUseCustomTargetRules(boolean useCustomTargetRules) {
      setBoolean(USE_CUSTOM_TARGET_RULES, useCustomTargetRules);
    }
  
    public String getCustomTargetRulesPath() {
      return getString(CUSTOM_TARGET_RULES_PATH);
    }
  
    public void setCustomTargetRulesPath(String customTargetRulesPath) {
      setString(CUSTOM_TARGET_RULES_PATH, customTargetRulesPath);
    }
  
    public boolean isCollapseWhitespace() {
      return getBoolean(COLLAPSE_WHITESPACE);
    }
 
   public void setCollapseWhitespace(boolean collapseWhitespace) {
     setBoolean(COLLAPSE_WHITESPACE, collapseWhitespace);
   }
 
   public boolean isUseCodesReinsertionModel() {
     return getBoolean(USE_CODES_REINSERTION_MODEL);
   }
 
   public void setUseCodesReinsertionModel(boolean useCodesReinsertionModel) {
     setBoolean(USE_CODES_REINSERTION_MODEL, useCodesReinsertionModel);
   }
 
   public String getCodesReinsertionModelName() {
     return getString(CODES_REINSERTION_MODEL_NAME);
   }
 
   public void setCodesReinsertionModelName(String modelName) {
     setString(CODES_REINSERTION_MODEL_NAME, modelName);
   }
 
   @Override
   public void reset() {
     super.reset();
     
     setAlignmentModelName(Const.GEMINI_ALIGNMENT_MODEL);
     setMaxParagraphsPerRequest(1000);
     setLogAlignmentDetails(true);
 
     setSegmentSource(true);
     setUseCustomSourceRules(false);
     setCustomSourceRulesPath("");
 
     setSegmentTarget(true);
     setUseCustomTargetRules(false);
     setCustomTargetRulesPath("");
     setCollapseWhitespace(false);
 
     setUseCodesReinsertionModel(false);
     setCodesReinsertionModelName(Const.GEMINI_CODE_REINSERTION_MODEL);
   }
 
   @Override
   public ParametersDescription getParametersDescription() {
     ParametersDescription desc = new ParametersDescription(this);
 
     desc.add(ALIGNMENT_MODEL_NAME,
         "LLM model to use for alignment",
         "The Gemini AI model name (e.g., 'gpt-4o-mini', 'gpt-4o')");
 
     desc.add(MAX_PARAGRAPHS_PER_REQUEST,
         "Maximum paragraphs per LLM request",
         "For very large documents, split into batches of this many paragraphs to avoid token limits.");
 
     desc.add(LOG_ALIGNMENT_DETAILS,
         "Log detailed alignment information",
         "If true, logs detailed information about alignments (useful for debugging but verbose).");
 
     desc.add(SEGMENT_SOURCE,
         "Segment the source content (overriding possible existing segmentation)",
         null);
 
     desc.add(USE_CUSTOM_SOURCE_RULES,
         "Use custom source segmentation rules (instead of the default ones)",
         null);
 
     desc.add(CUSTOM_SOURCE_RULES_PATH,
         "SRX path for the source",
         "Full path of the SRX document to use for the source");
 
     desc.add(SEGMENT_TARGET,
         "Segment the target content (overriding possible existing segmentation)",
         null);
 
     desc.add(USE_CUSTOM_TARGET_RULES,
         "Use custom target segmentation rules (instead of the default ones)",
         null);
 
     desc.add(CUSTOM_TARGET_RULES_PATH,
         "SRX path for the target",
         "Full path of the SRX document to use for the target");
 
     desc.add(COLLAPSE_WHITESPACE,
         "Collapse whitespace",
         "Collapse whitespace (space, newline etc.) to a single space before segmentation and alignment");
 
     desc.add(USE_CODES_REINSERTION_MODEL,
         "Use LLM-based target codes reinsertion",
         "True to use LLM-based target codes reinsertion, false to have Okapi reinsert. " +
         "This option has effect only when plainTextMT is true.");
 
     desc.add(CODES_REINSERTION_MODEL_NAME,
         "Gemini AI model name for target codes reinsertion",
         "Gemini model to use for reinserting inline codes in the target text.");
 
     return desc;
   }
 }