package com.acumenvelocity.ath.mt.confidence;
   
   import java.util.List;
   import java.util.stream.Collectors;
   
   import com.acumenvelocity.ath.mt.confidence.CommonDataStructures.LanguagePairSupport;
   
   import net.sf.okapi.common.resource.TextFragment;
   
  /**
   * Data structures for the HybridQualityEstimator.
   */
  public class HybridDataStructures {
  
    public enum EvaluationStrategy {
      VERTEX_ONLY("Vertex AI only (MetricX/COMET)"),
      VERTEX_WITH_HEURISTIC_VALIDATION("Vertex AI primary with Heuristic Validation"),
      VERTEX_WITH_HEURISTIC_SUPPLEMENT("Vertex AI (COMET) with Heuristic Supplement"),
      HEURISTIC_ONLY("Heuristic-only evaluation");
  
      private final String description;
  
      EvaluationStrategy(String description) {
        this.description = description;
      }
  
      @Override
      public String toString() {
        return description;
      }
    }
  
    /**
     * Represents a single translation with combined scores from all estimators.
     */
    public static class HybridTranslationScore {
      private final String modelId;
      private final String translation;
      private final double confidence; // Final, adjusted score
      private final Double metricXScore;
      private final Double cometScore;
      private final Double heuristicScore;
      private final String method; // e.g., "vertex_validated", "heuristic_only"
      private boolean anomalyFlagged;
      private String anomalyReason;
  
      public HybridTranslationScore(String modelId, String translation, double confidence,
          Double metricXScore, Double cometScore, Double heuristicScore, String method) {
        
        this.modelId = modelId;
        this.translation = translation;
        this.confidence = confidence;
        this.metricXScore = metricXScore;
        this.cometScore = cometScore;
        this.heuristicScore = heuristicScore;
        this.method = method;
        this.anomalyFlagged = false;
      }
  
      public void flagAnomaly(String reason) {
        this.anomalyFlagged = true;
        this.anomalyReason = reason;
      }
  
      public String getModelId() {
        return modelId;
      }
  
      public String getTranslation() {
        return translation;
      }
  
      public double getConfidence() {
        return confidence;
      }
  
      public Double getMetricXScore() {
        return metricXScore;
      }
  
      public Double getCometScore() {
        return cometScore;
      }
  
      public Double getHeuristicScore() {
        return heuristicScore;
      }
  
      public String getMethod() {
        return method;
      }
  
      public boolean isAnomalyFlagged() {
        return anomalyFlagged;
      }
  
      public String getAnomalyReason() {
        return anomalyReason;
      }
 
     @Override
     public String toString() {
       String anomaly = anomalyFlagged ? String.format(" [ANOMALY: %s]", anomalyReason) : "";
       
       return String.format("[%s, %s] %s | Confidence: %.3f | COMET: %.3f | Heuristic: %.3f%s",
           modelId,
           method,
           translation.substring(0, Math.min(translation.length(), 60))
               + (translation.length() > 60 ? "..." : ""),
           confidence,
           cometScore != null ? cometScore : Double.NaN,
           heuristicScore != null ? heuristicScore : Double.NaN,
           anomaly);
     }
   }
 
   /**
    * Represents all hybrid-scored translations for a single source segment.
    */
   public static class HybridScoredSegment {
     private final int segmentId;
     private final String sourceText;
     private final TextFragment sourceTf;
     private final List<HybridTranslationScore> scores;
 
     public HybridScoredSegment(int segmentId, String sourceText, TextFragment sourceTf,
         List<HybridTranslationScore> scores) {
       
       this.segmentId = segmentId;
       this.sourceText = sourceText;
       this.sourceTf = sourceTf;
       this.scores = scores;
     }
 
     public int getSegmentId() {
       return segmentId;
     }
 
     public String getSourceText() {
       return sourceText;
     }
 
     public List<HybridTranslationScore> getScores() {
       return scores;
     }
 
     public HybridTranslationScore getBestTranslation() {
       return scores.isEmpty() ? null : scores.get(0);
     }
 
     public void printReport() {
       System.out.printf("\n=== Segment %d ===%n", segmentId);
       System.out.printf("Source: %s%n", sourceText);
       System.out.println("\nRanked Translations:");
       
       for (int i = 0; i < scores.size(); i++) {
         System.out.printf("%d. %s%n", i + 1, scores.get(i));
       }
     }
 
     public TextFragment getSourceTf() {
       return sourceTf;
     }
   }
 
   /**
    * The final result object for the hybrid evaluation.
    */
   public static class HybridEvaluationResult {
     private final List<HybridScoredSegment> segments;
     private final EvaluationStrategy strategy;
     private final LanguagePairSupport support;
 
     public HybridEvaluationResult(List<HybridScoredSegment> segments, EvaluationStrategy strategy,
         LanguagePairSupport support) {
       
       this.segments = segments;
       this.strategy = strategy;
       this.support = support;
     }
 
     public List<HybridScoredSegment> getSegments() {
       return segments;
     }
 
     public EvaluationStrategy getStrategy() {
       return strategy;
     }
 
     public LanguagePairSupport getSupport() {
       return support;
     }
 
     public void printFullReport() {
       System.out.println("\n========================================");
       System.out.println("====== HYBRID EVALUATION REPORT =======");
       System.out.println("========================================");
       System.out.println(support);
       System.out.printf("Evaluation Strategy: %s%n", strategy);
 
       for (HybridScoredSegment segment : segments) {
         segment.printReport();
       }
 
       // Summarize
       System.out.println("\n========================================");
       System.out.println("Average Confidence by Model:");
       
       segments.stream()
           .flatMap(s -> s.getScores().stream())
           .collect(Collectors.groupingBy(HybridTranslationScore::getModelId,
               Collectors.averagingDouble(HybridTranslationScore::getConfidence)))
           .forEach((model, avg) -> System.out.printf(" %s: %.3f%n", model, avg));
       
       System.out.println("========================================");
     }
   }
 }