package com.acumenvelocity.ath.controller;
   
   import java.util.ArrayList;
   import java.util.List;
   import java.util.stream.Collectors;
   
   import com.acumenvelocity.ath.common.ControllerUtil;
   import com.acumenvelocity.ath.common.Response;
   import com.acumenvelocity.ath.model.EncodingInfo;
  import com.acumenvelocity.ath.model.EncodingInfosWrapper;
  import com.acumenvelocity.ath.model.FilterInfo;
  import com.acumenvelocity.ath.model.FilterInfosWrapper;
  import com.acumenvelocity.ath.model.LanguageInfo;
  import com.acumenvelocity.ath.model.LanguageInfosWrapper;
  import com.acumenvelocity.ath.model.PaginationInfo;
  
  import io.swagger.oas.inflector.models.RequestContext;
  import io.swagger.oas.inflector.models.ResponseContext;
  
  /**
   * REST Controller for handling Okapi framework related operations.
   * Provides endpoints for retrieving language, encoding, and filter information
   * from the Okapi framework with pagination support.
   * 
   * <p>
   * This controller integrates with Swagger/OpenAPI for API documentation
   * and follows RESTful best practices.
   * </p>
   * 
   * @author Acumen Velocity
   * @version 1.0
   * @since 1.0
   */
  public class OkapiController {
  
    /**
     * Retrieves a paginated list of available languages with 2-character ISO codes only.
     *
     * <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>
     * <b>Language Code Filter:</b>
     * Only languages with 2-character ISO 639-1 codes are returned (e.g., "en", "fr", "de").
     * Languages with 3-character codes or regional variants (e.g., "ace", "en-US") are excluded.
     * </p>
     *
     * @param request  the HTTP request context provided by 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 language list or error details
     *
     * @apiNote GET /languages
     */
    public ResponseContext getLanguages(RequestContext request, Integer page, Integer pageSize) {
      try {
        // Retrieve and filter languages (2-letter codes only)
        List<LanguageInfo> filteredLanguages = ControllerUtil.getLanguageInfos().stream()
            .filter(lang -> {
              String code = lang.getIsoCode();
              return code != null && code.length() == 2 && !code.contains("-");
            })
            .collect(Collectors.toList());
  
        LanguageInfosWrapper wrapper = new LanguageInfosWrapper();
  
        // Empty result case
        if (filteredLanguages.isEmpty()) {
          wrapper.languages(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 = filteredLanguages.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<LanguageInfo> resultLanguages;
  
        if (page == null && pageSize == null) {
          // No pagination requested → return all as "page 1"
          pageNum = 1;
          resultLanguages = filteredLanguages;
          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, filteredLanguages.size());
         resultLanguages = filteredLanguages.subList(start, end);
       }
 
       // Fluent construction — exactly like your preferred style
       PaginationInfo pagination = new PaginationInfo()
           .page(pageNum)
           .pageSize(size)
           .totalItems(totalItems)
           .totalPages(totalPages)
           .hasNext(pageNum < totalPages)
           .hasPrevious(pageNum > 1);
 
       wrapper.languages(resultLanguages)
           .pagination(pagination);
 
       return Response.success(200, wrapper);
 
     } catch (Exception e) {
       return Response.error(500, e, "Error fetching languages");
     }
   }
 
   /**
    * Retrieves a paginated list of available languages from Okapi framework.
    * 
    * <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>
    *
    * @param request  the HTTP request context provided by 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 locale list or error details
    * 
    * @apiNote GET /locales
    */
   public ResponseContext getLocales(RequestContext request, Integer page, Integer pageSize) {
     try {
       List<LanguageInfo> allLanguages = ControllerUtil.getLanguageInfos();
       LanguageInfosWrapper wrapper = new LanguageInfosWrapper();
 
       // Empty result
       if (allLanguages.isEmpty()) {
         wrapper.languages(new ArrayList<>())
             .pagination(new PaginationInfo()
                 .page(1)
                 .pageSize(0)
                 .totalItems(0L)
                 .totalPages(0)
                 .hasNext(false)
                 .hasPrevious(false));
 
         return Response.success(200, wrapper);
       }
 
       // Default page size
       long totalItems = allLanguages.size();
       int size = (pageSize != null) ? Math.max(1, Math.min(100, pageSize)) : (int) totalItems;      
       int totalPages = (int) Math.ceil(totalItems / (double) size);
 
       int pageNum;
       List<LanguageInfo> resultLanguages;
 
       if (page == null && pageSize == null) {
         // No pagination requested → return everything as page 1
         pageNum = 1;
         resultLanguages = allLanguages;
         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, allLanguages.size());
         resultLanguages = allLanguages.subList(start, end);
       }
 
       // Fluent construction — exactly your preferred style
       PaginationInfo pagination = new PaginationInfo()
           .page(pageNum)
           .pageSize(size)
           .totalItems(totalItems)
           .totalPages(totalPages)
           .hasNext(pageNum < totalPages)
           .hasPrevious(pageNum > 1);
 
       wrapper.languages(resultLanguages)
           .pagination(pagination);
 
       return Response.success(200, wrapper);
 
     } catch (Exception e) {
       return Response.error(500, e, "Error fetching locales");
     }
   }
 
   /**
    * Retrieves a paginated list of available encodings from Okapi framework.
    * 
    * <p>
    * Follows the same pagination logic as {@link #getLanguages(RequestContext, Integer, Integer)}.
    * </p>
    *
    * @param request  the HTTP request context provided by 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 encoding list or error details
    * 
    * @apiNote GET /encodings
    */
   public ResponseContext getEncodings(RequestContext request, Integer page, Integer pageSize) {
     try {
       List<EncodingInfo> allEncodings = ControllerUtil.getEncodingInfos();
       EncodingInfosWrapper wrapper = new EncodingInfosWrapper();
 
       // Empty result
       if (allEncodings.isEmpty()) {
         wrapper.encodings(new ArrayList<>())
             .pagination(new PaginationInfo()
                 .page(1)
                 .pageSize(0)
                 .totalItems(0L)
                 .totalPages(0)
                 .hasNext(false)
                 .hasPrevious(false));
         
         return Response.success(200, wrapper);
       }
 
       // Page size with bounds
       long totalItems = allEncodings.size();
       int size = (pageSize != null) ? Math.max(1, Math.min(100, pageSize)) : (int) totalItems;      
       int totalPages = (int) Math.ceil(totalItems / (double) size);
 
       int pageNum;
       List<EncodingInfo> resultEncodings;
 
       if (page == null && pageSize == null) {
         // No pagination → return all as page 1
         pageNum = 1;
         resultEncodings = allEncodings;
         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, allEncodings.size());
         resultEncodings = allEncodings.subList(start, end);
       }
 
       // Fluent pagination object (your preferred style)
       PaginationInfo pagination = new PaginationInfo()
           .page(pageNum)
           .pageSize(size)
           .totalItems(totalItems)
           .totalPages(totalPages)
           .hasNext(pageNum < totalPages)
           .hasPrevious(pageNum > 1);
 
       // Fluent wrapper population
       wrapper.encodings(resultEncodings)
           .pagination(pagination);
 
       return Response.success(200, wrapper);
 
     } catch (Exception e) {
       return Response.error(500, e, "Error fetching encodings");
     }
   }
 
   /**
    * Retrieves a paginated list of available filter configurations from Okapi framework.
    * 
    * <p>
    * Follows the same pagination logic as {@link #getLanguages(RequestContext, Integer, Integer)}.
    * </p>
    *
    * @param request  the HTTP request context provided by 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 filter list or error details
    * 
    * @apiNote GET /filters
    */
   public ResponseContext getFilters(RequestContext request, Integer page, Integer pageSize) {
     try {
       List<FilterInfo> allFilters = ControllerUtil.getFilterInfos();
       FilterInfosWrapper wrapper = new FilterInfosWrapper();
 
       // Empty result
       if (allFilters.isEmpty()) {
         wrapper.filters(new ArrayList<>())
             .pagination(new PaginationInfo()
                 .page(1)
                 .pageSize(0)
                 .totalItems(0L)
                 .totalPages(0)
                 .hasNext(false)
                 .hasPrevious(false));
         
         return Response.success(200, wrapper);
       }
 
       // Page size (1–100)
       long totalItems = allFilters.size();
       int size = (pageSize != null) ? Math.max(1, Math.min(100, pageSize)) : (int) totalItems;      
       int totalPages = (int) Math.ceil(totalItems / (double) size);
 
       int pageNum;
       List<FilterInfo> resultFilters;
 
       if (page == null && pageSize == null) {
         // No pagination → return all as page 1
         pageNum = 1;
         resultFilters = allFilters;
         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, allFilters.size());
         resultFilters = allFilters.subList(start, end);
       }
 
       // Fluent PaginationInfo (your preferred style)
       PaginationInfo pagination = new PaginationInfo()
           .page(pageNum)
           .pageSize(size)
           .totalItems(totalItems)
           .totalPages(totalPages)
           .hasNext(pageNum < totalPages)
           .hasPrevious(pageNum > 1);
 
       // Fluent wrapper
       wrapper.filters(resultFilters)
           .pagination(pagination);
 
       return Response.success(200, wrapper);
 
     } catch (Exception e) {
       return Response.error(500, e, "Error fetching filters");
     }
   }
 }