package com.acumenvelocity.ath.common;
   
   import java.io.File;
   import java.util.HashMap;
   import java.util.Map;
   
   import javax.ws.rs.core.MediaType;
   import javax.ws.rs.core.Response.Status;
   
  import com.acumenvelocity.ath.model.ResponseCodeMessage;
  
  import io.swagger.oas.inflector.models.ResponseContext;
  import net.sf.okapi.common.Util;
  
  /**
   * Utility class for creating standardized HTTP responses in a REST API context.
   * Provides methods for creating success and error responses with consistent
   * formatting and content types.
   * 
   * <p>
   * All responses are returned as JSON with UTF-8 encoding and include
   * appropriate HTTP status codes and logging.
   * </p>
   * 
   * @author Acumen Velocity
   * @version 1.0
   * @since 1.0
   * @see ResponseContext
   * @see ResponseCodeMessage
   */
  public class Response {
    // Media type constants for consistent content type handling
    static public final MediaType APPLICATION_JSON_MEDIA_TYPE = new MediaType("application", "json");
    static public final String APPLICATION_JSON = APPLICATION_JSON_MEDIA_TYPE.toString();
  
    static public final MediaType APPLICATION_JSON_UTF8_MEDIA_TYPE = new MediaType("application",
        "json", "utf-8");
    static public final String APPLICATION_JSON_UTF8 = APPLICATION_JSON_UTF8_MEDIA_TYPE.toString();
  
    /**
     * Creates a standardized response with the specified status code and message.
     * Automatically logs the message at appropriate level based on status code.
     * 
     * @param code    the HTTP status code (2xx for success, others for errors)
     * @param message the response message text
     * @return ResponseContext configured with status, entity, and content type
     */
    private static ResponseContext makeResponse(int code, String message) {
      // Log success responses at INFO level, errors at WARN level
      if (code >= 200 && code <= 299) {
        Log.info(Response.class, message);
      } else {
        Log.warn(Response.class, message);
      }
  
      // Create response code object and serialize to JSON
      ResponseCodeMessage rc = new ResponseCodeMessage();
      rc.setCode(code);
      rc.setMessage(message);
      String st = JacksonUtil.toJson(rc, false);
  
      // Build and return the response context
      return new ResponseContext()
          .status(code)
          .entity(EncodingUtil.toUtf8(st)) // Ensure UTF-8 encoding
          .contentType(APPLICATION_JSON_UTF8_MEDIA_TYPE);
    }
  
    /**
     * Creates an error response with the specified status code and message.
     * 
     * @param code    the HTTP error status code (e.g., 400, 404, 500)
     * @param message the error message text
     * @return ResponseContext for the error response
     */
    public static ResponseContext error(int code, String message) {
      return makeResponse(code, message);
    }
  
    /**
     * Creates an error response with formatted message.
     * 
     * @param code      the HTTP error status code
     * @param format    the message format string with placeholders
     * @param arguments the values for the placeholders
     * @return ResponseContext for the error response
     */
    public static ResponseContext error(int code, String format, Object... arguments) {
      String message = Log.format(format, arguments);
      return error(code, message);
    }
  
    /**
     * Creates an error response with exception details.
     * 
     * @param code    the HTTP error status code
     * @param cause   the exception that caused the error
     * @param message the error message text
     * @return ResponseContext for the error response
    */
   public static ResponseContext error(int code, Throwable cause, String message) {
     String st = Log.format("{} -- {}", message, unwindCause(cause));
     Log.error(Response.class, st);
     return makeResponse(code, st);
   }
 
   public static String unwindCause(Throwable t) {
     if (t == null) {
       return "";
     }
 
     StringBuilder sb = new StringBuilder();
     Throwable cur = t;
 
     while (cur != null) {
       String msg = cur.getMessage();
 
       if (msg != null && !msg.isBlank()) {
         if (sb.length() > 0) {
           sb.append(" -- ");
         }
 
         sb.append(msg.trim());
       }
 
       cur = cur.getCause();
 
       if (cur == t) {
         break; // guard against circular cause chains
       }
     }
 
     return sb.toString();
   }
 
   /**
    * Creates an error response with exception details and formatted message.
    * 
    * @param code      the HTTP error status code
    * @param cause     the exception that caused the error
    * @param format    the message format string with placeholders
    * @param arguments the values for the placeholders
    * @return ResponseContext for the error response
    */
   public static ResponseContext error(int code, Throwable cause, String format,
       Object... arguments) {
     return error(code, cause, Log.format(format, arguments));
   }
 
   /**
    * Creates a success response with formatted message.
    * 
    * @param code      the HTTP success status code (e.g., 200, 201)
    * @param format    the message format string with placeholders
    * @param arguments the values for the placeholders
    * @return ResponseContext for the success response
    */
   public static ResponseContext success(int code, String format, Object... arguments) {
     String message = Log.format(format, arguments);
     return success(code, message);
   }
 
   /**
    * Creates a success response with an object as the response body.
    * The object will be serialized to JSON.
    * 
    * @param code the HTTP success status code
    * @param obj  the object to include in the response body
    * @return ResponseContext for the success response
    */
   public static ResponseContext success(int code, Object obj) {
     return success(code, obj, true);
   }
 
   /**
    * Creates a success response with an object as the response body.
    * Provides control over ObjectId serialization format.
    * 
    * @param code                   the HTTP success status code
    * @param obj                    the object to include in the response body
    * @param forceObjectIdAsObjects if true, ObjectIds are serialized as objects;
    *                               if false, they are serialized as strings
    * @return ResponseContext for the success response
    */
   public static ResponseContext success(int code, Object obj, boolean forceObjectIdAsObjects) {
     // Handle string objects separately
     if (obj instanceof String) {
       return makeResponse(code, (String) obj);
     }
 
     // Serialize object to JSON with specified ObjectId handling
     // Note: The current implementation uses the same serializer regardless of the flag
     // This may need to be updated to use different ObjectMapper instances
     String st = forceObjectIdAsObjects ? JacksonUtil.toJson(obj, false)
         : JacksonUtil.toJson(obj, false);
 
     return new ResponseContext()
         .status(code)
         .entity(EncodingUtil.toUtf8(st))
         .contentType(APPLICATION_JSON_UTF8_MEDIA_TYPE);
   }
 
   /**
    * Creates a simple success response with default "Success" message.
    * 
    * @param code the HTTP success status code
    * @return ResponseContext for the success response
    */
   public static ResponseContext success(int code) {
     return makeResponse(code, "Success");
   }
 
   public static ResponseContext makeResponse(Status status, Object obj, String headerKey,
       String headerValue) {
 
     // Handle String and File objects separately
     if (obj instanceof String) {
       return makeResponse(status.getStatusCode(), (String) obj);
 
     } else if (obj instanceof File) {
       return new ResponseContext()
           .status(status)
           .header(headerKey, headerValue)
           .contentType(MediaType.APPLICATION_OCTET_STREAM)
           .entity(obj);
     }
 
     // Any other object
     String st = JacksonUtil.toJson(obj, false);
 
     return Util.isEmpty(headerKey) || Util.isEmpty(headerValue) ? new ResponseContext()
         .status(status)
         .entity(EncodingUtil.toUtf8(st)) // Ensure UTF-8 encoding
         .contentType(Response.APPLICATION_JSON_UTF8_MEDIA_TYPE)
         : new ResponseContext()
             .status(status)
             .header(headerKey, headerValue)
             .entity(EncodingUtil.toUtf8(st)) // Ensure UTF-8 encoding
             .contentType(Response.APPLICATION_JSON_UTF8_MEDIA_TYPE);
   }
 
   /**
    * Creates a builder for constructing a ResponseContext with chained method calls.
    * 
    * @return a new Builder instance
    */
   public static Builder builder() {
     return new Builder();
   }
 
   /**
    * Builder class for creating ResponseContext instances with a fluent API.
    */
   public static class Builder {
     private Status status;
     private Object entity;
     private final Map<String, String> headers = new HashMap<>();
 
     /**
      * Sets the HTTP status for the response.
      * 
      * @param status the HTTP status
      * @return this Builder for chaining
      */
     public Builder status(Status status) {
       this.status = status;
       return this;
     }
 
     /**
      * Adds a header to the response.
      * 
      * @param name  the header name
      * @param value the header value
      * @return this Builder for chaining
      */
     public Builder header(String name, String value) {
       if (!Util.isEmpty(name) && !Util.isEmpty(value)) {
         headers.put(name, value);
       }
       return this;
     }
 
     /**
      * Sets the entity for the response (serialized to JSON for non-String/File types).
      * 
      * @param entity the entity object
      * @return this Builder for chaining
      */
     public Builder entity(Object entity) {
       this.entity = entity;
       return this;
     }
 
     /**
      * Builds the ResponseContext with the configured status, headers, and entity.
      * 
      * @return the constructed ResponseContext
      */
     public ResponseContext build() {
       if (status == null) {
         throw new IllegalStateException("Status must be set");
       }
 
       if (entity == null) {
         return makeResponse(status.getStatusCode(), "Success");
       }
 
       ResponseContext context = new ResponseContext();
       context.status(status);
 
       for (Map.Entry<String, String> header : headers.entrySet()) {
         context.header(header.getKey(), header.getValue());
       }
 
       if (entity instanceof String) {
         return makeResponse(status.getStatusCode(), (String) entity);
 
       } else if (entity instanceof File) {
         context.contentType(MediaType.APPLICATION_OCTET_STREAM);
         context.entity(entity);
 
       } else {
         String st = JacksonUtil.toJson(entity, false);
         context.entity(EncodingUtil.toUtf8(st));
         context.contentType(APPLICATION_JSON_UTF8_MEDIA_TYPE);
       }
 
       return context;
     }
   }
 
   public static String getMessage(ResponseContext res) {
     ResponseCodeMessage rcm = JacksonUtil.fromJson(res.getEntity().toString(),
         ResponseCodeMessage.class);
 
     return rcm == null ? null : rcm.getMessage();
   }
 }