package com.acumenvelocity.ath.controller;
   
   import java.net.URI;
   import java.util.ArrayList;
   import java.util.Date;
   import java.util.List;
   import java.util.UUID;
   
   import com.acumenvelocity.ath.common.AthUtil;
  import com.acumenvelocity.ath.common.ControllerUtil;
  import com.acumenvelocity.ath.common.Response;
  import com.acumenvelocity.ath.model.ModelInfo;
  import com.acumenvelocity.ath.model.ModelInfosWrapper;
  import com.acumenvelocity.ath.model.PaginationInfo;
  import com.acumenvelocity.ath.model.TrainModelRequest;
  import com.acumenvelocity.ath.model.TrainingCompletedResponse;
  import com.acumenvelocity.ath.model.TrainingFailedResponse;
  import com.acumenvelocity.ath.model.TrainingJobResponse;
  import com.acumenvelocity.ath.model.TrainingJobStatus;
  import com.acumenvelocity.ath.model.TrainingStatusResponse;
  import com.acumenvelocity.ath.service.AutoMlTrainingService;
  import com.fasterxml.jackson.databind.JsonNode;
  
  import io.swagger.oas.inflector.models.RequestContext;
  import io.swagger.oas.inflector.models.ResponseContext;
  
  /**
   * REST Controller for handling AutoML custom model training operations.
   * Provides endpoints for training custom translation models, checking training status,
   * cancelling training jobs, and listing trained models.
   * 
   * <p>
   * This controller manages the full lifecycle of AutoML training jobs:
   * <ul>
   * <li>Scanning GCS buckets for training files (TMX, TSV, CSV, TXT)</li>
   * <li>Creating AutoML datasets</li>
   * <li>Importing training data</li>
   * <li>Training custom models</li>
   * <li>Monitoring training progress</li>
   * </ul>
   * </p>
   * 
   * <p>
   * All training operations are asynchronous and follow the same pattern as
   * document import/export operations. Training job state is persisted in Solr
   * (ath_automl_jobs core) for durability and multi-node coordination.
   * </p>
   * 
   * @author Acumen Velocity
   * @version 1.0
   * @since 1.0
   */
  public class AutoMlController {
  
    private final AutoMlTrainingService trainingService;
  
    /**
     * Constructor with dependency injection for the training service.
     * 
     * @param trainingService the service handling AutoML training operations
     */
    public AutoMlController(AutoMlTrainingService trainingService) {
      this.trainingService = trainingService;
    }
  
    /**
     * Default constructor for Swagger Inflector.
     * Initializes the training service with default configuration.
     */
    public AutoMlController() {
      this.trainingService = new AutoMlTrainingService();
    }
  
    /**
     * Initiates an asynchronous AutoML model training job.
     * 
     * <p>
     * This endpoint:
     * <ol>
     * <li>Validates the training request parameters</li>
     * <li>Creates a training job record in Solr</li>
     * <li>Initiates background processing</li>
     * <li>Returns immediately with 202 Accepted</li>
     * </ol>
     * </p>
     * 
     * <p>
     * <b>Training Process:</b>
     * </p>
     * <ul>
     * <li>SCANNING_BUCKETS: Recursively scanning GCS buckets for files</li>
     * <li>PREPARING_DATASET: Creating AutoML dataset resource</li>
     * <li>IMPORTING_DATA: Importing training files into dataset</li>
     * <li>TRAINING: Training the custom model (takes several hours)</li>
     * <li>COMPLETED: Model ready for use</li>
     * <li>FAILED: Training failed with error details</li>
     * </ul>
     * 
     * <p>
    * <b>File Format Support:</b>
    * Automatically detects and processes TMX, TSV, CSV, and TXT files.
    * </p>
    * 
    * <p>
    * <b>Data Validation:</b>
    * </p>
    * <ul>
    * <li>Minimum segments: 1,000 (returns 400 Bad Request if less)</li>
    * <li>Maximum segments: 15,000,000 (returns 400 Bad Request if more)</li>
    * <li>Automatic 80/10/10 split for train/validation/test</li>
    * </ul>
    *
    * @param request       the HTTP request context from Swagger Inflector
    * @param trainingJobId UUID for the training job (provided by client)
    * @param modelName     display name for the trained model
    * @param srcLang       source language ISO code (e.g., "en")
    * @param trgLang       target language ISO code (e.g., "es")
    * @param gcsBuckets    list of GCS bucket URIs to scan
    * @param projectId     GCP project ID for AutoML resources
    * @param location      GCP region for AutoML (e.g., "us-central1")
    * @param userId        UUID of the user initiating training
    * @return ResponseContext with 202 Accepted and status URL, or 400/409/500 on error
    * 
    * @apiNote POST /automl/model/train
    */
   public ResponseContext trainModel(RequestContext request, JsonNode bodyNode) {
     try {
       if (!ControllerUtil.checkParam(bodyNode)) {
         return Response.error(400, "Invalid request parameter, bodyNode is null");
       }
       
       TrainModelRequest body = AthUtil.safeFromJsonNode(bodyNode,
           TrainModelRequest.class, null);
 
       if (body == null) {
         return Response.error(400, "Invalid request body");
       }
       
       UUID trainingJobId = body.getTrainingJobId();
       String modelName = body.getModelName();
       String srcLang = body.getSrcLang();
       String trgLang = body.getTrgLang();
       List<URI> gcsBuckets = body.getGcsBuckets();
       String projectId = body.getProjectId();
       String location = body.getLocation();
       UUID userId = body.getUserId();
 
       if (!ControllerUtil.checkParam(trainingJobId)) {
         return Response.error(400, "training_job_id is required");
       }
 
       if (modelName == null || modelName.trim().isEmpty()) {
         return Response.error(400, "model_name is required");
       }
 
       if (srcLang == null || srcLang.trim().isEmpty()) {
         return Response.error(400, "src_lang is required");
       }
 
       if (trgLang == null || trgLang.trim().isEmpty()) {
         return Response.error(400, "trg_lang is required");
       }
 
       if (gcsBuckets == null || gcsBuckets.isEmpty()) {
         return Response.error(400, "gcs_buckets list is required and cannot be empty");
       }
 
       if (projectId == null || projectId.trim().isEmpty()) {
         return Response.error(400, "project_id is required");
       }
 
       if (location == null || location.trim().isEmpty()) {
         return Response.error(400, "location is required");
       }
 
       if (!ControllerUtil.checkParam(userId)) {
         return Response.error(400, "user_id is required");
       }
 
       // Validate GCS bucket URIs
       for (URI bucketUri : gcsBuckets) {
         if (!bucketUri.toString().startsWith("gs://")) {
           return Response.error(400, "Invalid GCS bucket URI: " + bucketUri +
               ". Must start with gs://");
         }
       }
 
       // Check if training job already exists
       if (trainingService.trainingJobExists(trainingJobId)) {
         return Response.error(409, "Training job with ID " + trainingJobId +
             " already exists");
       }
 
       // Initiate asynchronous training
       trainingService.initiateTraining(
           trainingJobId,
           modelName,
           srcLang,
           trgLang,
           gcsBuckets,
           projectId,
           location,
           userId);
 
       // Return 202 Accepted with status URL
       TrainingJobResponse response = new TrainingJobResponse()
           .status(TrainingJobResponse.StatusEnum.SCANNING_BUCKETS)
           .trainingJobId(trainingJobId)
           .statusUrl("/automl/model/train/" + trainingJobId + "/status")
           .submittedAt(new Date());
 
       ResponseContext responseContext = new ResponseContext()
           .status(202)
           .entity(response);
 
       responseContext.getHeaders().put("Location",
           List.of("/automl/model/train/" + trainingJobId + "/status"));
 
       return responseContext;
 
     } catch (IllegalArgumentException e) {
       return Response.error(400, e.getMessage());
 
     } catch (Exception e) {
       return Response.error(500, e, "Error initiating model training");
     }
   }
 
   /**
    * Retrieves the current status of an AutoML training job.
    * 
    * <p>
    * <b>Response Codes:</b>
    * </p>
    * <ul>
    * <li><b>202 Accepted:</b> Training in progress</li>
    * <li><b>200 OK:</b> Training completed successfully</li>
    * <li><b>500 Internal Server Error:</b> Training failed</li>
    * <li><b>404 Not Found:</b> Training job not found</li>
    * </ul>
    * 
    * <p>
    * <b>Status Values:</b>
    * </p>
    * <ul>
    * <li>SCANNING_BUCKETS: Scanning GCS buckets for training files</li>
    * <li>PREPARING_DATASET: Creating AutoML dataset</li>
    * <li>IMPORTING_DATA: Importing files to dataset</li>
    * <li>TRAINING: Training model (longest phase, typically hours)</li>
    * <li>COMPLETED: Training successful, model ready</li>
    * <li>FAILED: Training failed, see error details</li>
    * </ul>
    * 
    * <p>
    * <b>Polling Recommendations:</b>
    * </p>
    * <ul>
    * <li>SCANNING_BUCKETS / PREPARING_DATASET: Poll every 5-10 seconds</li>
    * <li>IMPORTING_DATA: Poll every 30-60 seconds</li>
    * <li>TRAINING: Poll every 5-10 minutes (training takes hours)</li>
    * </ul>
    *
    * @param request       the HTTP request context from Swagger Inflector
    * @param trainingJobId UUID of the training job
    * @return ResponseContext with current status (202, 200, 404, or 500)
    * 
    * @apiNote GET /automl/model/train/{training_job_id}/status
    */
   public ResponseContext getTrainingStatus(RequestContext request, UUID trainingJobId) {
     try {
       if (!ControllerUtil.checkParam(trainingJobId)) {
         return Response.error(400, "Invalid training_job_id format");
       }
 
       // Check if training job exists
       if (!trainingService.trainingJobExists(trainingJobId)) {
         return Response.error(404, "Training job not found: " + trainingJobId);
       }
 
       // Get current status
       TrainingJobStatus status = trainingService.getTrainingStatus(trainingJobId);
 
       if (status == null) {
         return Response.error(404, "Training job not found: " + trainingJobId);
       }
 
       switch (status) {
       case SCANNING_BUCKETS:
       case PREPARING_DATASET:
       case IMPORTING_DATA:
       case TRAINING:
         // Training in progress - return 202 Accepted
         TrainingStatusResponse inProgressResponse = new TrainingStatusResponse()
             .status(TrainingStatusResponse.StatusEnum.fromValue(status.name()))
             .trainingJobId(trainingJobId)
             .progress(trainingService.getProgress(trainingJobId))
             .startedAt(trainingService.getStartedAt(trainingJobId))
             .currentPhase(trainingService.getCurrentPhase(trainingJobId));
 
         ResponseContext inProgressContext = new ResponseContext()
             .status(202)
             .entity(inProgressResponse);
 
         // Add Retry-After header based on current phase
         int retryAfter = getRetryAfterSeconds(status);
         inProgressContext.getHeaders().put("Retry-After", List.of(String.valueOf(retryAfter)));
 
         return inProgressContext;
 
       case COMPLETED:
         // Training completed - return 200 OK
         TrainingCompletedResponse completedResponse = new TrainingCompletedResponse()
             .status(TrainingCompletedResponse.StatusEnum.COMPLETED)
             .trainingJobId(trainingJobId)
             .modelId(trainingService.getModelId(trainingJobId))
             .modelName(trainingService.getModelName(trainingJobId))
             .datasetId(trainingService.getDatasetId(trainingJobId))
             .completedAt(trainingService.getCompletedAt(trainingJobId))
             .datasetStats(trainingService.getDatasetStats(trainingJobId));
 
         return new ResponseContext()
             .status(200)
             .entity(completedResponse);
 
       case FAILED:
         // Training failed - return 500 Internal Server Error
         TrainingFailedResponse failedResponse = new TrainingFailedResponse()
             .status(TrainingFailedResponse.StatusEnum.FAILED)
             .trainingJobId(trainingJobId)
             .errorType(trainingService.getErrorType(trainingJobId))
             .errorMessage(trainingService.getErrorMessage(trainingJobId))
             .failedAt(trainingService.getFailedAt(trainingJobId));
 
         return new ResponseContext()
             .status(500)
             .entity(failedResponse);
 
       default:
         return Response.error(500, "Unknown training status: " + status);
       }
 
     } catch (Exception e) {
       return Response.error(500, e, "Error retrieving training status");
     }
   }
 
   /**
    * Cancels an in-progress AutoML training job.
    * 
    * <p>
    * <b>Cancellation Rules:</b>
    * </p>
    * <ul>
    * <li>Can cancel: SCANNING_BUCKETS, PREPARING_DATASET, IMPORTING_DATA, TRAINING</li>
    * <li>Cannot cancel: COMPLETED, FAILED (returns 409 Conflict)</li>
    * <li>Only the user who initiated the job can cancel it (403 Forbidden otherwise)</li>
    * <li>Once cancelled, the job cannot be resumed</li>
    * <li>Any created AutoML resources (dataset) may remain and should be cleaned up separately</li>
    * </ul>
    * 
    * <p>
    * <b>Best Practices:</b>
    * </p>
    * <ul>
    * <li>Check status before cancelling to avoid 409 errors</li>
    * <li>Consider cost implications of cancelling long-running training</li>
    * <li>Clean up any orphaned AutoML datasets if needed</li>
    * </ul>
    *
    * @param request       the HTTP request context from Swagger Inflector
    * @param trainingJobId UUID of the training job to cancel
    * @return ResponseContext with 204 No Content on success, 403/404/409/500 on error
    * 
    * @apiNote DELETE /automl/model/train/{training_job_id}
    */
   public ResponseContext cancelTraining(RequestContext request, UUID trainingJobId) {
     try {
       // Validate trainingJobId
       if (!ControllerUtil.checkParam(trainingJobId)) {
         return Response.error(400, "Invalid training_job_id format");
       }
 
       // Check if training job exists
       if (!trainingService.trainingJobExists(trainingJobId)) {
         return Response.error(404, "Training job not found: " + trainingJobId);
       }
 
       // Get current status
       TrainingJobStatus status = trainingService.getTrainingStatus(trainingJobId);
 
       // Check if training can be cancelled
       if (TrainingJobStatus.COMPLETED.equals(status)) {
         return Response.error(409,
             "Cannot cancel training - training has already completed successfully");
       }
 
       if (TrainingJobStatus.FAILED.equals(status)) {
         return Response.error(409,
             "Cannot cancel training - training has already failed");
       }
 
       if (TrainingJobStatus.CANCELLED.equals(status)) {
         return Response.error(409,
             "Cannot cancel training - training has already been cancelled");
       }
 
       // Cancel the training job
       trainingService.cancelTraining(trainingJobId);
 
       // Return 204 No Content
       return new ResponseContext().status(204);
 
     } catch (Exception e) {
       return Response.error(500, e, "Error cancelling training job");
     }
   }
 
   /**
    * Retrieves a paginated list of trained AutoML models.
    * 
    * <p>
    * <b>Pagination Details:</b>
    * </p>
    * <ul>
    * <li>Default page size: 10 items</li>
    * <li>Maximum page size: 100 items</li>
    * <li>Page numbers start from 1</li>
    * <li>Automatically adjusts invalid page numbers</li>
    * </ul>
    * 
    * <p>
    * Returns all successfully trained models, sorted by creation date (newest first).
    * Failed or cancelled training jobs are not included in the list.
    * </p>
    *
    * @param request  the HTTP request context from Swagger Inflector
    * @param page     the requested page number (1-based, optional)
    * @param pageSize the number of items per page (1-100, optional)
    * @return ResponseContext containing paginated model list or error details
    * 
    * @apiNote GET /automl/models
    */
   public ResponseContext getModels(RequestContext request, Integer page, Integer pageSize) {
     try {
       List<ModelInfo> allModels = trainingService.getAllModels();
       ModelInfosWrapper wrapper = new ModelInfosWrapper();
 
       // Empty result
       if (allModels.isEmpty()) {
         wrapper.models(new ArrayList<>())
             .pagination(new PaginationInfo()
                 .page(1)
                 .pageSize(0)
                 .totalItems(0L)
                 .totalPages(0)
                 .hasNext(false)
                 .hasPrevious(false));
 
         return Response.success(200, wrapper);
       }
 
       // Determine pagination parameters
       long totalItems = allModels.size();
       int size = (pageSize != null) ? Math.max(1, Math.min(100, pageSize)) : (int) totalItems;
       int totalPages = (int) Math.ceil((double) totalItems / size);
 
       int pageNum;
       List<ModelInfo> resultModels;
 
       if (page == null && pageSize == null) {
         // No pagination requested → return all as page 1
         pageNum = 1;
         resultModels = allModels;
         totalPages = 1;
 
       } else {
         // Pagination requested
         pageNum = (page != null) ? Math.max(1, Math.min(page, Math.max(1, totalPages))) : 1;
         int start = (pageNum - 1) * size;
         int end = Math.min(start + size, allModels.size());
         resultModels = allModels.subList(start, end);
       }
 
       // Build pagination info
       PaginationInfo pagination = new PaginationInfo()
           .page(pageNum)
           .pageSize(size)
           .totalItems(totalItems)
           .totalPages(totalPages)
           .hasNext(pageNum < totalPages)
           .hasPrevious(pageNum > 1);
 
       wrapper.models(resultModels)
           .pagination(pagination);
 
       return Response.success(200, wrapper);
 
     } catch (Exception e) {
       return Response.error(500, e, "Error fetching trained models");
     }
   }
 
   /**
    * Determines the suggested retry interval based on training phase.
    * 
    * @param status current training status
    * @return recommended seconds to wait before next poll
    */
   private int getRetryAfterSeconds(TrainingJobStatus status) {
     switch (status) {
     case SCANNING_BUCKETS:
     case PREPARING_DATASET:
       return 10; // Fast phases - check every 10 seconds
 
     case IMPORTING_DATA:
       return 60; // Medium phase - check every minute
 
     case TRAINING:
       return 300; // Slow phase - check every 5 minutes
 
     default:
       return 30; // Default to 30 seconds
     }
   }
 }