package com.acumenvelocity.ath.gct.v3;
   
   import java.io.FileInputStream;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.concurrent.CompletableFuture;
   import java.util.stream.Collectors;
   
   import com.acumenvelocity.ath.common.AthUtil;
  import com.acumenvelocity.ath.common.Const;
  import com.acumenvelocity.ath.common.Log;
  import com.acumenvelocity.ath.steps.BatchMtStep;
  import com.google.api.gax.core.FixedCredentialsProvider;
  import com.google.auth.oauth2.GoogleCredentials;
  import com.google.cloud.aiplatform.v1.LocationName;
  import com.google.cloud.translate.v3.GlossaryName;
  import com.google.cloud.translate.v3.TranslateTextGlossaryConfig;
  import com.google.cloud.translate.v3.TranslateTextRequest;
  import com.google.cloud.translate.v3.TranslateTextResponse;
  import com.google.cloud.translate.v3.TranslationServiceClient;
  import com.google.cloud.translate.v3.TranslationServiceSettings;
  
  import net.sf.okapi.common.Util;
  
  public class AthTranslation {
  
    private static TranslationServiceClient client;
  
    public static void init() throws Exception {
      if (client == null || client.isShutdown()) {
        TranslationServiceSettings.Builder settingsBuilder = TranslationServiceSettings.newBuilder();
  
        // Handle Authentication
        if (!Util.isEmpty(Const.ATH_GCP_SECRET_FILE)) {
          try (FileInputStream credentialsStream = new FileInputStream(Const.ATH_GCP_SECRET_FILE)) {
            GoogleCredentials credentials = GoogleCredentials.fromStream(credentialsStream);
            settingsBuilder.setCredentialsProvider(FixedCredentialsProvider.create(credentials));
          }
  
        } else if (!Util.isEmpty(Const.ATH_GCT_API_KEY)) {
          // NOTE: The Google Cloud V3 Java Client strongly prefers Service Account Credentials
          // (JSON).
          // API Keys are less common in V3 client usage but can be set via header providers if
          // absolutely necessary.
          // However, standard V3 usage implies ADC (Application Default Credentials).
          // If neither is provided, it falls back to Environment Variables
          // (GOOGLE_APPLICATION_CREDENTIALS).
          Log.warn(AthTranslation.class,
              "API Key provided, but Service Account Credentials (JSON file) are preferred for "
                  + "Google Cloud V3 Client.");
        }
  
        client = TranslationServiceClient.create(settingsBuilder.build());
      }
    }
  
    /**
     * Translate batch with a single model and glossary (processes in parallel batches if needed)
     */
    public static List<String> translateBatch(
        List<String> texts,
        String sourceLang,
        String targetLang,
        String mimeType,
        String projectId,
        String projectLocation,
        String mtModelProjectId,
        String mtModelProjectLocation,
        String mtModelId,
        String mtGlossaryProjectId,
        String mtGlossaryProjectLocation,
        String mtGlossaryId) {
  
      String fullModelName = null;
  
      try {
        // Google Cloud Translate v3 limits:
        // - Max 1024 text segments per request
        // - Max 30,000 codepoints (characters) total per request
        final int MAX_TEXTS_PER_BATCH = 1000; // Conservative limit under 1024
        final int MAX_CODEPOINTS_PER_BATCH = 25000; // Conservative limit under 30,000
  
        LocationName parent = LocationName.of(
            // ControllerUtil.getProjectId(),
            // params.getProjectLocation());
            projectId,
            projectLocation);
  
        // Prepare model name if specified
        if (!Util.isEmpty(mtModelId)) {
          String modelProjectId = AthUtil.fallback(mtModelProjectId, projectId);
  
          String modelProjectLocation = AthUtil.fallback(mtModelProjectLocation, projectLocation);
  
          // fullModelName = ModelName.of(
          // modelProjectId,
          // modelProjectLocation,
          // mtModelId).toString();
          
         fullModelName = Log.format("projects/{}/locations/{}/models/{}", modelProjectId,
             modelProjectLocation, mtModelId);
       }
 
       // Prepare glossary config if specified
       TranslateTextGlossaryConfig glossaryConfig = null;
 
       if (!Util.isEmpty(mtGlossaryId)) {
         String glossaryProjectId = AthUtil.fallback(mtGlossaryProjectId, projectId);
 
         String glossaryProjectLocation = AthUtil.fallback(
             mtGlossaryProjectLocation, projectLocation);
 
         GlossaryName glossaryName = GlossaryName.of(
             glossaryProjectId,
             glossaryProjectLocation,
             mtGlossaryId);
 
         glossaryConfig = TranslateTextGlossaryConfig.newBuilder()
             .setGlossary(glossaryName.toString())
             .build();
       }
 
       // Split texts into batches based on size and codepoint limits
       List<List<String>> batches = createBatches(texts, MAX_TEXTS_PER_BATCH,
           MAX_CODEPOINTS_PER_BATCH);
 
       // Process batches in parallel using CompletableFuture
       final String modelNameForLambda = fullModelName;
       final TranslateTextGlossaryConfig glossaryConfigForLambda = glossaryConfig;
 
       List<CompletableFuture<List<String>>> futures = batches.stream()
           .map(batch -> CompletableFuture
               .supplyAsync(
                   () -> translateSingleBatch(client, batch, sourceLang, targetLang, mimeType,
                       parent, modelNameForLambda, glossaryConfigForLambda)))
           .collect(Collectors.toList());
 
       // Wait for all futures to complete and collect results in order
       List<String> allTranslations = new ArrayList<>();
 
       for (CompletableFuture<List<String>> future : futures) {
         List<String> batchResult = future.get(); // This maintains order
 
         if (batchResult == null) {
           Log.error(BatchMtStep.class, "One of the translation batches failed");
           return null;
         }
 
         allTranslations.addAll(batchResult);
       }
 
       return allTranslations;
 
     } catch (Exception e) {
       Log.error(BatchMtStep.class, e, "Translation failed for model '{}'", fullModelName);
     }
 
     return null;
   }
 
   /**
    * Split texts into batches respecting both count and codepoint limits
    */
   private static List<List<String>> createBatches(List<String> texts, int maxTextsPerBatch,
       int maxCodepointsPerBatch) {
 
     List<List<String>> batches = new ArrayList<>();
     List<String> currentBatch = new ArrayList<>();
     int currentCodepoints = 0;
 
     for (String text : texts) {
       int textCodepoints = text.codePointCount(0, text.length());
 
       // Start new batch if adding this text would exceed limits
       if (!currentBatch.isEmpty() &&
           (currentBatch.size() >= maxTextsPerBatch ||
               currentCodepoints + textCodepoints > maxCodepointsPerBatch)) {
         batches.add(currentBatch);
         currentBatch = new ArrayList<>();
         currentCodepoints = 0;
       }
 
       currentBatch.add(text);
       currentCodepoints += textCodepoints;
     }
 
     // Add the last batch if not empty
     if (!currentBatch.isEmpty()) {
       batches.add(currentBatch);
     }
 
     return batches;
   }
 
   /**
    * Translate a single batch
    */
   private static List<String> translateSingleBatch(
       TranslationServiceClient client,
       List<String> batch,
       String sourceLang,
       String targetLang,
       String mimeType,
       LocationName parent,
       String fullModelName,
       TranslateTextGlossaryConfig glossaryConfig) {
 
     try {
       TranslateTextRequest.Builder requestBuilder = TranslateTextRequest.newBuilder()
           .setParent(parent.toString())
           .setSourceLanguageCode(sourceLang)
           .setTargetLanguageCode(targetLang)
           .addAllContents(batch)
           .setMimeType(mimeType);
 
       if (fullModelName != null) {
         requestBuilder.setModel(fullModelName);
       }
 
       if (glossaryConfig != null) {
         requestBuilder.setGlossaryConfig(glossaryConfig);
       }
 
       TranslateTextResponse response = client.translateText(requestBuilder.build());
 
       return response.getTranslationsList().stream()
           .map(com.google.cloud.translate.v3.Translation::getTranslatedText)
           .collect(Collectors.toList());
 
     } catch (Exception e) {
       Log.error(BatchMtStep.class, e, "Translation failed for batch");
       return null;
     }
   }
 
   /**
    * Translate with the standard NMT model.
    * 
    * @param translations
    * @param sourceLang
    * @param targetLang
    * @param mimeType
    * @param projectId
    * @param projectLocation
    * @return
    */
   public static List<String> translateBatch(List<String> translations, String sourceLang,
       String targetLang, String mimeType, String projectId, String projectLocation) {
 
     return translateBatch(translations, sourceLang, targetLang, mimeType, projectId,
         projectLocation, null, null, null, null, null, null);
   }
 
   public static void done() throws Exception {
     if (client != null) {
       client.close();
     }
   }
 
   public static TranslationServiceClient getClient() {
     return client;
   }
 }