package com.acumenvelocity.ath.common;
   
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   import java.util.Objects;
   
   import com.acumenvelocity.ath.model.InlineCode;
  import com.acumenvelocity.ath.model.InlineCodeRef;
  import com.acumenvelocity.ath.model.LayeredSegment;
  import com.acumenvelocity.ath.model.MtTargetInfo;
  import com.acumenvelocity.ath.model.x.LayeredTextX;
  import com.acumenvelocity.ath.mt.confidence.ConfidenceScoredTranslation;
  
  import net.sf.okapi.common.LocaleId;
  import net.sf.okapi.common.annotation.AltTranslation;
  import net.sf.okapi.common.annotation.AltTranslationsAnnotation;
  import net.sf.okapi.common.resource.Code;
  import net.sf.okapi.common.resource.TextContainer;
  import net.sf.okapi.common.resource.TextFragment;
  import net.sf.okapi.common.resource.TextFragment.TagType;
  
  public class ConversionUtil {
  
    /**
     * Converts a LayeredText to a TextFragment (Okapi format).
     * 
     * @param fs the LayeredText to convert
     * @return TextFragment representation, or null if input is null
     */
    public static TextFragment toTextFragment(LayeredTextX fs) {
      if (fs == null) {
        return null;
      }
  
      // Start with the raw text
      String text = fs.getText();
      if (text == null) {
        text = "";
      }
  
      TextFragment tf = new TextFragment();
      List<InlineCode> inlineCodes = fs.getCodes();
  
      if (inlineCodes == null || inlineCodes.isEmpty()) {
        // No codes, just append the text
        tf.append(text);
        return tf;
      }
  
      // Sort codes by position to process them in order
      List<InlineCode> sortedCodes = new ArrayList<>(inlineCodes);
      sortedCodes.sort((a, b) -> Integer.compare(a.getPosition(), b.getPosition()));
  
      int currentPos = 0;
      int textLength = text.length();
  
      for (InlineCode ic : sortedCodes) {
        int codePos = ic.getPosition();
  
        // Validate code position
        if (codePos < 0) {
          Log.warn(ConversionUtil.class,
              "Invalid code position {} (negative) for code id={}, skipping",
              codePos, ic.getId());
  
          continue;
        }
  
        if (codePos > textLength) {
          Log.warn(ConversionUtil.class,
              "Invalid code position {} (exceeds text length {}) for code id={}, clamping to end",
              codePos, textLength, ic.getId());
  
          codePos = textLength;
        }
  
        // Append text before this code
        if (codePos > currentPos) {
  
          // Additional safety check
          if (currentPos < textLength) {
            int endPos = Math.min(codePos, textLength);
            tf.append(text.substring(currentPos, endPos));
          }
        }
  
        // Convert TagType enum
        TagType tagType = ic.getTagType();
  
        // Create and append the code
        Code code = tf.append(
            tagType,
            ic.getType() != null ? ic.getType() : "",
            ic.getData() != null ? ic.getData() : "");
  
        // Set additional properties
        if (ic.getId() != null) {
         code.setId(ic.getId());
       }
 
       if (ic.getOuterData() != null && !ic.getOuterData().isEmpty()) {
         code.setOuterData(ic.getOuterData());
       }
 
       if (ic.getDisplayText() != null) {
         code.setDisplayText(ic.getDisplayText());
       }
 
       if (ic.getOriginalId() != null) {
         code.setOriginalId(ic.getOriginalId());
       }
 
       // Set flags
       if (ic.getFlag() != null) {
         int flag = ic.getFlag();
 
         if ((flag & 0x01) != 0) {
           code.setReferenceFlag(true);
         }
 
         if ((flag & 0x02) != 0) {
           code.setCloneable(true);
         }
 
         if ((flag & 0x04) != 0) {
           code.setDeleteable(true);
         }
       }
 
       currentPos = codePos;
     }
 
     // Append remaining text after last code
     if (currentPos < textLength) {
       tf.append(text.substring(currentPos));
     }
 
     return tf;
   }
 
   /**
    * Converts a TextFragment (Okapi format) to a LayeredText.
    * 
    * @param tf the TextFragment to convert
    * @return LayeredText representation, or null if input is null
    */
   public static LayeredTextX toLayeredText(TextFragment tf, LocaleId loc) {
     if (tf == null) {
       return null;
     }
 
     LayeredTextX fs = new LayeredTextX();
 
     if (loc != null) {
       fs.setLanguage(loc.toString());
     }
 
     // Set the plain text (without codes)
     fs.setText(tf.getText());
 
     // Set text with codes for reference
     fs.setTextWithCodes(tf.toText());
 
     List<InlineCode> inlineCodes = new ArrayList<>();
 
     if (tf.hasCode()) {
       String codedText = tf.getCodedText();
 
       int textPosition = 0; // Position in plain text
 
       for (int i = 0; i < codedText.length(); i++) {
         char ch = codedText.charAt(i);
 
         if (TextFragment.isMarker(ch)) {
           // This is a code marker
           char indexChar = codedText.charAt(++i);
           Code code = tf.getCode(indexChar);
 
           InlineCode ic = new InlineCode();
           ic.setPosition(textPosition);
           ic.setId(code.getId());
           ic.setType(code.getType());
           ic.setData(code.getData());
 
           // Convert TagType
           ic.setTagType(code.getTagType());
 
           // Set additional properties
           if (code.getOuterData() != null && !code.getOuterData().isEmpty()) {
             ic.setOuterData(code.getOuterData());
           }
 
           if (code.getDisplayText() != null) {
             ic.setDisplayText(code.getDisplayText());
           }
 
           if (code.getOriginalId() != null) {
             ic.setOriginalId(code.getOriginalId());
           }
 
           // Convert flags
           int flag = 0;
           if (code.hasReference())
             flag |= 0x01;
 
           if (code.isCloneable())
             flag |= 0x02;
 
           if (code.isDeleteable())
             flag |= 0x04;
 
           ic.setFlag(flag);
 
           inlineCodes.add(ic);
 
         } else {
           // Regular character
           textPosition++;
         }
       }
     }
 
     fs.setCodes(inlineCodes);
 
     return fs;
   }
 
   public static LayeredSegment toLayeredSegment(LayeredTextX slt, LayeredTextX tlt) {
     LayeredSegment lseg = new LayeredSegment();
 
     lseg.setSrcLang(slt.getLanguage());
     lseg.setSrcText(slt.getText());
 
     lseg.setTrgLang(tlt.getLanguage());
     lseg.setTrgText(tlt.getText());
 
     // Source codes
     List<InlineCodeRef> codeRefs = new ArrayList<>();
 
     for (InlineCode c : slt.getCodes()) {
       InlineCodeRef cr = new InlineCodeRef();
 
       cr.setId(c.getId());
       cr.setTagType(c.getTagType());
       cr.setPosition(c.getPosition());
 
       codeRefs.add(cr);
     }
 
     lseg.setSrcCodes(codeRefs);
 
     // Target codes
     codeRefs = new ArrayList<>();
 
     for (InlineCode c : tlt.getCodes()) {
       InlineCodeRef cr = new InlineCodeRef();
 
       cr.setId(c.getId());
       cr.setTagType(c.getTagType());
       cr.setPosition(c.getPosition());
 
       codeRefs.add(cr);
     }
 
     lseg.setTrgCodes(codeRefs);
 
     return lseg;
   }
 
   /**
    * Converts a LayeredSegment to a LayeredTextX by resolving inline code references.
    * 
    * <p>
    * This method takes the target text and code references from a LayeredSegment and
    * matches them with full InlineCode objects from a source LayeredTextX. The code
    * references (InlineCodeRef) contain only the id, position, and tagType, while the
    * full InlineCode objects contain additional metadata like data, outerData, type,
    * flags, etc.
    * </p>
    * 
    * <p>
    * InlineCode objects are uniquely identified by the combination of their id and
    * tagType fields, as ids alone may not be unique (e.g., opening and closing tags
    * may share the same id but have different tagTypes).
    * </p>
    * 
    * @param lseg the LayeredSegment containing target text and code references to resolve
    * @param slt  the source LayeredTextX containing the full InlineCode objects to match against
    * @return a new LayeredTextX with the target language and text from lseg, and codes
    *         resolved from slt with positions updated from the code references. Returns
    *         null if either parameter is null.
    */
   public static LayeredTextX tltFromLayeredSegment(LayeredSegment lseg, LayeredTextX slt) {
     if (lseg == null || slt == null) {
       return null;
     }
 
     LayeredTextX result = new LayeredTextX();
 
     // Set language and text from the target side of the segment
     result.setLanguage(lseg.getTrgLang());
     result.setText(lseg.getTrgText());
 
     int maxPos = lseg.getTrgText().length() == 0 ? 0 : lseg.getTrgText().length() - 1;
 
     // Get code references from the segment's target
     List<InlineCodeRef> codeRefs = lseg.getTrgCodes();
 
     // Get full code objects from the source LayeredTextX
     List<InlineCode> sourceCodes = slt.getCodes();
 
     // Create a composite key class for unique identification
     class CodeKey {
       final Integer id;
       final TagType tagType;
 
       CodeKey(Integer id, TagType tagType) {
         this.id = id;
         this.tagType = tagType;
       }
 
       @Override
       public boolean equals(Object o) {
         if (this == o)
           return true;
 
         if (o == null || getClass() != o.getClass())
           return false;
 
         CodeKey codeKey = (CodeKey) o;
         return Objects.equals(id, codeKey.id) && tagType == codeKey.tagType;
       }
 
       @Override
       public int hashCode() {
         return Objects.hash(id, tagType);
       }
     }
 
     // Create a map for quick lookup of codes by id and tagType
     Map<CodeKey, InlineCode> codeMap = new HashMap<>();
     if (sourceCodes != null) {
       for (InlineCode code : sourceCodes) {
         codeMap.put(new CodeKey(code.getId(), code.getTagType()), code);
       }
     }
 
     // Build the result codes list by matching references to full codes
     List<InlineCode> resultCodes = new ArrayList<>();
 
     if (codeRefs != null) {
       for (InlineCodeRef ref : codeRefs) {
         InlineCode fullCode = codeMap.get(new CodeKey(ref.getId(), ref.getTagType()));
 
         if (fullCode != null) {
           // Create a new InlineCode with updated position from the reference
           InlineCode newCode = new InlineCode();
 
           newCode.setId(fullCode.getId());
 
           if (ref.getPosition() > maxPos) {
             Log.warn(ConversionUtil.class,
                 "Code position from LLM exceeds the length of '{}', normalizing",
                 lseg.getTrgText());
 
             newCode.setPosition(maxPos);
 
           } else {
             newCode.setPosition(ref.getPosition());
           }
 
           newCode.setType(fullCode.getType());
           newCode.setTagType(ref.getTagType());
           newCode.setData(fullCode.getData());
           newCode.setOuterData(fullCode.getOuterData());
           newCode.setFlag(fullCode.getFlag());
           newCode.setDisplayText(fullCode.getDisplayText());
           newCode.setOriginalId(fullCode.getOriginalId());
 
           resultCodes.add(newCode);
         }
       }
     }
 
     result.setCodes(resultCodes);
 
     return result;
   }
 
   public static List<MtTargetInfo> toMtTargets(AltTranslationsAnnotation ata) {
     List<MtTargetInfo> altTrans = new ArrayList<>();
 
     for (AltTranslation at : ata) {
       if (at instanceof ConfidenceScoredTranslation) {
         ConfidenceScoredTranslation cst = (ConfidenceScoredTranslation) at;
 
         MtTargetInfo mti = new MtTargetInfo();
 
         TextContainer target = cst.getTarget();
         TextFragment ttf = target.getFirstContent();
         LayeredTextX tlt = ConversionUtil.toLayeredText(ttf, cst.getTargetLocale());
 
         mti.setMtTarget(tlt);
         mti.setMtConfidenceScore(cst.getConfidenceScore());
         mti.setMtModelId(cst.getOrigin());
         
         altTrans.add(mti);
       }
     }
 
     return altTrans;
   }
 }