/*
    * #%L
    * wcm.io
    * %%
    * Copyright (C) 2024 wcm.io
    * %%
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * #L%
   */
  package io.wcm.handler.mediasource.ngdm.impl.metadata;
  
  import static com.day.cq.dam.api.DamConstants.TIFF_IMAGELENGTH;
  import static com.day.cq.dam.api.DamConstants.TIFF_IMAGEWIDTH;
  
  import java.util.Collections;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.TreeMap;
  import java.util.stream.Collectors;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.lang3.builder.ToStringBuilder;
  import org.apache.sling.api.resource.ValueMap;
  import org.apache.sling.api.wrappers.ValueMapDecorator;
  import org.jetbrains.annotations.NotNull;
  import org.jetbrains.annotations.Nullable;
  
  import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.databind.json.JsonMapper;
  
  import io.wcm.handler.media.Dimension;
  import io.wcm.handler.mediasource.ngdm.impl.metadata.MetadataResponse.RepositoryMetadata;
  import io.wcm.wcm.commons.contenttype.ContentType;
  import io.wcm.wcm.commons.util.ToStringStyle;
  
  /**
   * Metadata for Next Gen Dynamic Media asset fetched from the HTTP API.
   */
  public final class NextGenDynamicMediaMetadata {
  
    private final String mimeType;
    private final Long fileSize;
    private final Dimension dimension;
    private final String assetStatus;
    private final ValueMap properties;
    private final List<SmartCrop> smartCrops;
  
    private static final JsonMapper OBJECT_MAPPER = new JsonMapper();
    static final String RT_RENDITION_SMARTCROP = "dam/rendition/smartcrop";
  
    NextGenDynamicMediaMetadata(@Nullable String mimeType, @Nullable Long fileSize, @Nullable Dimension dimension,
        @Nullable String assetStatus, @Nullable ValueMap properties, @Nullable List<SmartCrop> smartCrops) {
      this.mimeType = mimeType;
      this.fileSize = fileSize;
      this.dimension = dimension;
      this.assetStatus = assetStatus;
      if (properties != null) {
        this.properties = properties;
      }
      else {
        this.properties = ValueMap.EMPTY;
      }
      if (smartCrops != null) {
        this.smartCrops = smartCrops;
      }
      else {
        this.smartCrops = Collections.emptyList();
      }
    }
  
    /**
     * @return Mime type
     */
    public @NotNull String getMimeType() {
      return Objects.toString(mimeType, ContentType.OCTET_STREAM);
    }
  
    /**
     * @return File size (in bytes) or null if not available
     */
    public @Nullable Long getFileSize() {
      return fileSize;
    }
  
    /**
     * @return Image Dimension or null if no image or dimension not available
     */
    public @Nullable Dimension getDimension() {
     return dimension;
   }
 
   /**
    * @return Asset review status
    */
   public String getAssetStatus() {
     return this.assetStatus;
   }
 
   /**
    * @return Asset properties
    */
   public ValueMap getProperties() {
     return properties;
   }
 
   /**
    * @return Named smart crop definitions.
    */
   public List<SmartCrop> getSmartCrops() {
     return Collections.unmodifiableList(smartCrops);
   }
 
   /**
    * @return true if metadata is valid (has mime type)
    */
   public boolean isValid() {
     return mimeType != null;
   }
 
   @Override
   public String toString() {
     return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_OMIT_NULL_STYLE)
         .append("mimeType", mimeType)
         .append("fileSize", fileSize)
         .append("dimension", dimension)
         .append("assetStatus", assetStatus)
         .append("properties", properties.isEmpty() ? null : new TreeMap<String, Object>(properties))
         .append("smartCrops", smartCrops.isEmpty() ? null : smartCrops)
         .toString();
   }
 
   /**
    * Converts JSON response from NGDM API to metadata object.
    * @param jsonResponse JSON response
    * @return Metadata object
    * @throws JsonProcessingException If JSON parsing fails
    */
   @SuppressWarnings("null")
   public static @NotNull NextGenDynamicMediaMetadata fromJson(@NotNull String jsonResponse) throws JsonProcessingException {
     MetadataResponse response = OBJECT_MAPPER.readValue(jsonResponse, MetadataResponse.class);
     RepositoryMetadata respositoryMetadata = response.repositoryMetadata;
     Map<String, Object> assetMetadata = response.assetMetadata;
     ValueMap properties = null;
 
     long width = 0;
     long height = 0;
     String assetStatus = null;
     if (assetMetadata != null) {
       properties = new ValueMapDecorator(assetMetadata);
       width = properties.get(TIFF_IMAGEWIDTH, 0L);
       height = properties.get(TIFF_IMAGELENGTH, 0L);
       assetStatus = properties.get("dam:assetStatus", String.class);
     }
     Dimension dimension = toDimension(width, height);
 
     String mimeType = null;
     Long fileSize = null;
     List<SmartCrop> smartCrops = null;
     if (respositoryMetadata != null) {
       mimeType = respositoryMetadata.dcFormat;
       fileSize = respositoryMetadata.repoSize;
       if (respositoryMetadata.smartCrops != null && dimension != null) {
         smartCrops = respositoryMetadata.smartCrops.entrySet().stream()
             .filter(entry -> isSmartCropDefinitionValid(entry.getKey(), entry.getValue()))
             .map(entry -> new SmartCrop(entry.getKey(), entry.getValue(), dimension))
             .collect(Collectors.toList());
       }
     }
 
     return new NextGenDynamicMediaMetadata(mimeType, fileSize, dimension, assetStatus, properties, smartCrops);
   }
 
   private static @Nullable Dimension toDimension(long width, long height) {
     if (width > 0 && height > 0) {
       return new Dimension(width, height);
     }
     return null;
   }
 
   private static boolean isSmartCropDefinitionValid(@NotNull String name, @NotNull MetadataResponse.SmartCrop smartCop) {
     return StringUtils.isNotBlank(name)
         && smartCop.normalizedWidth > 0
         && smartCop.normalizedHeight > 0
         && smartCop.left >= 0
         && smartCop.top >= 0;
   }
 
 }