/*
    * Copyright (C) 2023 B3Partners B.V.
    *
    * SPDX-License-Identifier: MIT
    */
   package org.tailormap.api.persistence;
   
   import com.fasterxml.jackson.annotation.JsonIgnore;
   import io.hypersistence.tsid.TSID;
  import jakarta.persistence.Basic;
  import jakarta.persistence.Column;
  import jakarta.persistence.Entity;
  import jakarta.persistence.EntityListeners;
  import jakarta.persistence.EnumType;
  import jakarta.persistence.Enumerated;
  import jakarta.persistence.FetchType;
  import jakarta.persistence.Id;
  import jakarta.persistence.PrePersist;
  import jakarta.persistence.Transient;
  import jakarta.persistence.Version;
  import jakarta.validation.constraints.NotNull;
  import java.lang.invoke.MethodHandles;
  import java.nio.charset.StandardCharsets;
  import java.time.Instant;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Optional;
  import org.apache.commons.lang3.StringUtils;
  import org.hibernate.annotations.Type;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.lang.NonNull;
  import org.springframework.util.LinkedMultiValueMap;
  import org.springframework.util.MultiValueMap;
  import org.springframework.web.util.UriComponentsBuilder;
  import org.tailormap.api.persistence.helper.GeoServiceHelper;
  import org.tailormap.api.persistence.json.AuthorizationRule;
  import org.tailormap.api.persistence.json.GeoServiceDefaultLayerSettings;
  import org.tailormap.api.persistence.json.GeoServiceLayer;
  import org.tailormap.api.persistence.json.GeoServiceLayerSettings;
  import org.tailormap.api.persistence.json.GeoServiceProtocol;
  import org.tailormap.api.persistence.json.GeoServiceSettings;
  import org.tailormap.api.persistence.json.ServiceAuthentication;
  import org.tailormap.api.persistence.json.TMServiceCaps;
  import org.tailormap.api.persistence.listener.EntityEventPublisher;
  import org.tailormap.api.repository.FeatureSourceRepository;
  import org.tailormap.api.util.TMStringUtils;
  import org.tailormap.api.viewer.model.Service;
  
  @Entity
  @EntityListeners(EntityEventPublisher.class)
  public class GeoService {
    private static final Logger logger =
        LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
  
    private static final List<String> REMOVE_PARAMS = List.of("REQUEST");
  
    @Id private String id;
  
    @Version private Long version;
  
    @Column(columnDefinition = "text")
    private String notes;
  
    @NotNull
    @Enumerated(EnumType.STRING)
    private GeoServiceProtocol protocol;
  
    /**
     * The URL from which the capabilities of this service can be loaded and the URL to use for the
     * service, except when the advertisedUrl should be used by explicit user request. TODO: never use
     * URL in capabilities? TODO: explicitly specify relative URLs can be used? Or even if it should
     * be automatically converted to a relative URL if the hostname/port matches our URL? TODO: what
     * to do with parameters such as VERSION in the URL?
     */
    @NotNull
    @Column(length = 2048)
    private String url;
  
    @Transient private boolean refreshCapabilities;
  
    /**
     * Non-null when authentication is required for this service. Currently, the only authentication
     * method is password (HTTP Basic).
     */
    @Type(value = io.hypersistence.utils.hibernate.type.json.JsonBinaryType.class)
    @Column(columnDefinition = "jsonb")
    private ServiceAuthentication authentication;
  
    /**
     * Original capabilities as received from the service. This can be used for capability information
     * not already parsed in this entity, such as tiling information.
     */
    @Basic(fetch = FetchType.LAZY)
    @JsonIgnore
    private byte[] capabilities;
  
   /**
    * Content type of capabilities. "application/xml" for WMS/WMTS and "application/json" for REST
    * services.
    */
   private String capabilitiesContentType;
 
   /** The instant the capabilities where last successfully fetched and parsed. */
   private Instant capabilitiesFetched;
 
   /** Title loaded from capabilities or as modified by user for display. */
   @NotNull
   @Column(length = 2048)
   private String title;
 
   /**
    * A service may advertise a URL in its capabilities which does not actually work, for example if
    * the service is behind a proxy. Usually this shouldn't be used.
    */
   @Column(length = 2048)
   private String advertisedUrl;
 
   @Type(value = io.hypersistence.utils.hibernate.type.json.JsonBinaryType.class)
   @Column(columnDefinition = "jsonb")
   private TMServiceCaps serviceCapabilities;
 
   @Type(value = io.hypersistence.utils.hibernate.type.json.JsonBinaryType.class)
   @Column(columnDefinition = "jsonb")
   @NotNull
   private List<AuthorizationRule> authorizationRules = new ArrayList<>();
 
   @Type(value = io.hypersistence.utils.hibernate.type.json.JsonBinaryType.class)
   @Column(columnDefinition = "jsonb")
   @NotNull
   private List<GeoServiceLayer> layers = new ArrayList<>();
 
   private boolean published;
 
   /**
    * Settings relevant for Tailormap use cases, such as configuring the specific server type for
    * vendor-specific capabilities etc.
    */
   @Type(value = io.hypersistence.utils.hibernate.type.json.JsonBinaryType.class)
   @Column(columnDefinition = "jsonb")
   @NotNull
   private GeoServiceSettings settings = new GeoServiceSettings();
 
   // <editor-fold desc="getters and setters">
   public String getId() {
     return id;
   }
 
   public GeoService setId(String id) {
     this.id = id;
     return this;
   }
 
   public Long getVersion() {
     return version;
   }
 
   public GeoService setVersion(Long version) {
     this.version = version;
     return this;
   }
 
   public String getNotes() {
     return notes;
   }
 
   public GeoService setNotes(String adminComments) {
     this.notes = adminComments;
     return this;
   }
 
   public GeoServiceProtocol getProtocol() {
     return protocol;
   }
 
   public GeoService setProtocol(GeoServiceProtocol protocol) {
     this.protocol = protocol;
     return this;
   }
 
   public String getUrl() {
     return url;
   }
 
   /** Sets the url after sanitising (removing unwanted parameters). */
   public GeoService setUrl(String url) {
     this.url = sanitiseUrl(url);
     return this;
   }
 
   public boolean isRefreshCapabilities() {
     return refreshCapabilities;
   }
 
   public void setRefreshCapabilities(boolean refreshCapabilities) {
     this.refreshCapabilities = refreshCapabilities;
   }
 
   public ServiceAuthentication getAuthentication() {
     return authentication;
   }
 
   public GeoService setAuthentication(ServiceAuthentication authentication) {
     this.authentication = authentication;
     return this;
   }
 
   public byte[] getCapabilities() {
     return capabilities;
   }
 
   public GeoService setCapabilities(byte[] capabilities) {
     this.capabilities = capabilities;
     return this;
   }
 
   public String getCapabilitiesContentType() {
     return capabilitiesContentType;
   }
 
   public GeoService setCapabilitiesContentType(String capabilitiesContentType) {
     this.capabilitiesContentType = capabilitiesContentType;
     return this;
   }
 
   public Instant getCapabilitiesFetched() {
     return capabilitiesFetched;
   }
 
   public GeoService setCapabilitiesFetched(Instant capabilitiesFetched) {
     this.capabilitiesFetched = capabilitiesFetched;
     return this;
   }
 
   public String getTitle() {
     return title;
   }
 
   public GeoService setTitle(String title) {
     this.title = title;
     return this;
   }
 
   public String getAdvertisedUrl() {
     return advertisedUrl;
   }
 
   public GeoService setAdvertisedUrl(String advertisedUrl) {
     this.advertisedUrl = advertisedUrl;
     return this;
   }
 
   public TMServiceCaps getServiceCapabilities() {
     return serviceCapabilities;
   }
 
   public GeoService setServiceCapabilities(TMServiceCaps serviceCapabilities) {
     this.serviceCapabilities = serviceCapabilities;
     return this;
   }
 
   public List<AuthorizationRule> getAuthorizationRules() {
     return authorizationRules;
   }
 
   public GeoService setAuthorizationRules(List<AuthorizationRule> authorizationRules) {
     this.authorizationRules = authorizationRules;
     return this;
   }
 
   public List<GeoServiceLayer> getLayers() {
     return layers;
   }
 
   public GeoService setLayers(List<GeoServiceLayer> layers) {
     this.layers = layers;
     return this;
   }
 
   public boolean isPublished() {
     return published;
   }
 
   public GeoService setPublished(boolean published) {
     this.published = published;
     return this;
   }
 
   public GeoServiceSettings getSettings() {
     return settings;
   }
 
   public GeoService setSettings(GeoServiceSettings settings) {
     this.settings = settings;
     return this;
   }
 
   // </editor-fold>
 
   @PrePersist
   public void assignId() {
     if (StringUtils.isBlank(getId())) {
       // We kind of misuse TSIDs here, because we store it as a string. This is because the id
       // string can also be manually assigned. There won't be huge numbers of GeoServices, so it's
       // more of a convenient way to generate an ID that isn't a huge UUID string.
       setId(TSID.fast().toString());
     }
   }
 
   public Service toJsonPojo(GeoServiceHelper geoServiceHelper) {
     Service.ServerTypeEnum serverTypeEnum;
     if (settings.getServerType() == GeoServiceSettings.ServerTypeEnum.AUTO) {
       serverTypeEnum = geoServiceHelper.guessServerTypeFromUrl(getUrl());
     } else {
       serverTypeEnum = Service.ServerTypeEnum.fromValue(settings.getServerType().getValue());
     }
 
     Service s =
         new Service()
             .id(this.id)
             .title(this.title)
             .url(Boolean.TRUE.equals(this.getSettings().getUseProxy()) ? null : this.url)
             .protocol(this.protocol)
             .serverType(serverTypeEnum);
 
     if (this.protocol == GeoServiceProtocol.WMTS) {
       // Frontend requires WMTS capabilities to parse TilingMatrix, but WMS capabilities aren't used
       // XXX UTF-8 only, maybe use base64
       s.capabilities(new String(getCapabilities(), StandardCharsets.UTF_8));
     }
 
     return s;
   }
 
   public GeoServiceLayer findLayer(String name) {
     return getLayers().stream().filter(sl -> name.equals(sl.getName())).findFirst().orElse(null);
   }
 
   public GeoServiceLayerSettings getLayerSettings(String layerName) {
     return getSettings().getLayerSettings().get(layerName);
   }
 
   @NonNull
   public String getTitleWithSettingsOverrides(String layerName) {
     // First use title in layer settings
     String title =
         Optional.ofNullable(getLayerSettings(layerName))
             .map(GeoServiceLayerSettings::getTitle)
             .map(TMStringUtils::nullIfEmpty)
             .orElse(null);
 
     // If not set, title from capabilities
     if (title == null) {
       title =
           Optional.ofNullable(findLayer(layerName))
               .map(GeoServiceLayer::getTitle)
               .map(TMStringUtils::nullIfEmpty)
               .orElse(null);
     }
 
     // Do not get title from default layer settings (a default title wouldn't make sense)
 
     // If still not set, use layer name as title
     if (title == null) {
       title = layerName;
     }
 
     return title;
   }
 
   public TMFeatureType findFeatureTypeForLayer(
       GeoServiceLayer layer, FeatureSourceRepository featureSourceRepository) {
 
     GeoServiceDefaultLayerSettings defaultLayerSettings = getSettings().getDefaultLayerSettings();
     GeoServiceLayerSettings layerSettings = getLayerSettings(layer.getName());
 
     Long featureSourceId = null;
     String featureTypeName;
 
     if (layerSettings != null && layerSettings.getFeatureType() != null) {
       featureTypeName =
           Optional.ofNullable(layerSettings.getFeatureType().getFeatureTypeName())
               .orElse(layer.getName());
       featureSourceId = layerSettings.getFeatureType().getFeatureSourceId();
     } else {
       featureTypeName = layer.getName();
     }
 
     if (featureSourceId == null
         && defaultLayerSettings != null
         && defaultLayerSettings.getFeatureType() != null) {
       featureSourceId = defaultLayerSettings.getFeatureType().getFeatureSourceId();
     }
 
     if (featureTypeName == null) {
       return null;
     }
 
     TMFeatureSource tmfs = null;
     TMFeatureType tmft = null;
 
     if (featureSourceId == null) {
       List<TMFeatureSource> linkedSources = featureSourceRepository.findByLinkedServiceId(getId());
       for (TMFeatureSource linkedFs : linkedSources) {
         tmft = linkedFs.findFeatureTypeByName(featureTypeName);
         if (tmft != null) {
           tmfs = linkedFs;
           break;
         }
       }
     } else {
       tmfs = featureSourceRepository.findById(featureSourceId).orElse(null);
       if (tmfs != null) {
         tmft = tmfs.findFeatureTypeByName(featureTypeName);
       }
     }
 
     if (tmfs == null) {
       return null;
     }
 
     if (tmft == null) {
       String[] split = featureTypeName.split(":", 2);
       if (split.length == 2) {
         String shortFeatureTypeName = split[1];
         tmft = tmfs.findFeatureTypeByName(shortFeatureTypeName);
         if (tmft != null) {
           logger.debug(
               "Did not find feature type with full name \"{}\", using \"{}\" of feature source {}",
               featureTypeName,
               shortFeatureTypeName,
               tmfs);
         }
       }
     }
     return tmft;
   }
 
   /**
    * Remove all parameters from the URL that are listed in {@link #REMOVE_PARAMS}.
    *
    * @param url URL to sanitise
    * @return sanitised URL
    */
   private String sanitiseUrl(String url) {
     if (url != null && url.contains("?")) {
       MultiValueMap<String, String> sanitisedParams = new LinkedMultiValueMap<>();
       UriComponentsBuilder uri = UriComponentsBuilder.fromUriString(url);
       MultiValueMap<String, String> /* unmodifiable */ requestParams = uri.build().getQueryParams();
       for (Map.Entry<String, List<String>> param : requestParams.entrySet()) {
         if (!REMOVE_PARAMS.contains(param.getKey().toUpperCase(Locale.ROOT))) {
           sanitisedParams.put(param.getKey(), param.getValue());
         }
       }
 
       url = uri.replaceQueryParams(sanitisedParams).build().toUriString();
       if (url.endsWith("?")) {
         url = url.substring(0, url.length() - 1);
       }
     }
     return url;
   }
 }