/*
    * Copyright (C) 2023 B3Partners B.V.
    *
    * SPDX-License-Identifier: MIT
    */
   package org.tailormap.api.persistence.helper;
   
   import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.linkTo;
   import static org.tailormap.api.persistence.json.GeoServiceProtocol.PROXIEDLEGEND;
  import static org.tailormap.api.persistence.json.GeoServiceProtocol.QUANTIZEDMESH;
  import static org.tailormap.api.persistence.json.GeoServiceProtocol.TILES3D;
  import static org.tailormap.api.persistence.json.GeoServiceProtocol.XYZ;
  import static org.tailormap.api.util.TMStringUtils.nullIfEmpty;
  
  import jakarta.persistence.EntityManager;
  import java.lang.invoke.MethodHandles;
  import java.net.URI;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Optional;
  import java.util.Set;
  import org.apache.commons.lang3.ObjectUtils;
  import org.apache.commons.lang3.tuple.Triple;
  import org.geotools.api.referencing.crs.CoordinateReferenceSystem;
  import org.geotools.referencing.util.CRSUtilities;
  import org.geotools.referencing.wkt.Formattable;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;
  import org.tailormap.api.controller.GeoServiceProxyController;
  import org.tailormap.api.persistence.Application;
  import org.tailormap.api.persistence.Configuration;
  import org.tailormap.api.persistence.GeoService;
  import org.tailormap.api.persistence.SearchIndex;
  import org.tailormap.api.persistence.TMFeatureType;
  import org.tailormap.api.persistence.json.AppContent;
  import org.tailormap.api.persistence.json.AppLayerSettings;
  import org.tailormap.api.persistence.json.AppTreeLayerNode;
  import org.tailormap.api.persistence.json.AppTreeLevelNode;
  import org.tailormap.api.persistence.json.AppTreeNode;
  import org.tailormap.api.persistence.json.Bounds;
  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.ServicePublishingSettings;
  import org.tailormap.api.persistence.json.TileLayerHiDpiMode;
  import org.tailormap.api.repository.ApplicationRepository;
  import org.tailormap.api.repository.ConfigurationRepository;
  import org.tailormap.api.repository.FeatureSourceRepository;
  import org.tailormap.api.repository.GeoServiceRepository;
  import org.tailormap.api.repository.SearchIndexRepository;
  import org.tailormap.api.security.AuthorizationService;
  import org.tailormap.api.viewer.model.AppLayer;
  import org.tailormap.api.viewer.model.LayerSearchIndex;
  import org.tailormap.api.viewer.model.LayerTreeNode;
  import org.tailormap.api.viewer.model.MapResponse;
  import org.tailormap.api.viewer.model.TMCoordinateReferenceSystem;
  
  @Service
  public class ApplicationHelper {
    private static final Logger logger =
        LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
    private static final String DEFAULT_WEB_MERCATOR_CRS = "EPSG:3857";
  
    private final GeoServiceHelper geoServiceHelper;
    private final GeoServiceRepository geoServiceRepository;
    private final ConfigurationRepository configurationRepository;
    private final ApplicationRepository applicationRepository;
    private final FeatureSourceRepository featureSourceRepository;
    private final EntityManager entityManager;
    private final AuthorizationService authorizationService;
    private final SearchIndexRepository searchIndexRepository;
  
    public ApplicationHelper(
        GeoServiceHelper geoServiceHelper,
        GeoServiceRepository geoServiceRepository,
        ConfigurationRepository configurationRepository,
        ApplicationRepository applicationRepository,
        FeatureSourceRepository featureSourceRepository,
        EntityManager entityManager,
        AuthorizationService authorizationService,
        SearchIndexRepository searchIndexRepository) {
      this.geoServiceHelper = geoServiceHelper;
      this.geoServiceRepository = geoServiceRepository;
      this.configurationRepository = configurationRepository;
      this.applicationRepository = applicationRepository;
      this.featureSourceRepository = featureSourceRepository;
      this.entityManager = entityManager;
      this.authorizationService = authorizationService;
      this.searchIndexRepository = searchIndexRepository;
    }
  
    public Application getServiceApplication(String baseAppName, String projection, GeoService service) {
      if (baseAppName == null) {
        baseAppName = Optional.ofNullable(service.getSettings().getPublishing())
            .map(ServicePublishingSettings::getBaseApp)
           .orElseGet(() -> configurationRepository.get(Configuration.DEFAULT_BASE_APP));
     }
 
     Application baseApp = null;
     if (baseAppName != null) {
       baseApp = applicationRepository.findByName(baseAppName);
       if (baseApp != null) {
         // Caller may be changing the app content to add layers from this service, detach so those
         // aren't saved
         entityManager.detach(baseApp);
       }
     }
 
     Application app = baseApp != null ? baseApp : new Application().setContentRoot(new AppContent());
 
     if (projection != null) {
       // TODO: filter layers by projection parameter (layer.crs must inherit crs from parent layers)
       throw new UnsupportedOperationException("Projection filtering not yet supported");
     } else {
       if (baseApp != null) {
         projection = baseApp.getCrs();
       } else {
         projection = DEFAULT_WEB_MERCATOR_CRS;
       }
     }
 
     app.setName(service.getId()).setTitle(service.getTitle()).setCrs(projection);
 
     return app;
   }
 
   @Transactional
   public MapResponse toMapResponse(Application app) {
     MapResponse mapResponse = new MapResponse();
     setCrsAndBounds(app, mapResponse);
     setLayers(app, mapResponse);
     return mapResponse;
   }
 
   public void setCrsAndBounds(Application a, MapResponse mapResponse) {
     CoordinateReferenceSystem gtCrs = a.getGeoToolsCoordinateReferenceSystem();
     if (gtCrs == null) {
       throw new IllegalArgumentException("Invalid CRS: " + a.getCrs());
     }
 
     TMCoordinateReferenceSystem crs = new TMCoordinateReferenceSystem()
         .code(a.getCrs())
         .definition(((Formattable) gtCrs).toWKT(0))
         .bounds(GeoToolsHelper.fromCRS(gtCrs))
         .unit(Optional.ofNullable(CRSUtilities.getUnit(gtCrs.getCoordinateSystem()))
             .map(Objects::toString)
             .orElse(null));
 
     Bounds maxExtent = a.getMaxExtent() != null ? a.getMaxExtent() : crs.getBounds();
     Bounds initialExtent = a.getInitialExtent() != null ? a.getInitialExtent() : maxExtent;
 
     mapResponse.crs(crs).maxExtent(maxExtent).initialExtent(initialExtent);
   }
 
   public void setLayers(Application app, MapResponse mr) {
     new MapResponseLayerBuilder(app, mr).buildLayers();
   }
 
   private String getProxyUrl(GeoService geoService, Application application, AppTreeLayerNode appTreeLayerNode) {
     String baseProxyUrl = linkTo(
             GeoServiceProxyController.class,
             Map.of(
                 "viewerKind", "app", // XXX
                 "viewerName", application.getName(),
                 "appLayerId", appTreeLayerNode.getId()))
         .toString();
 
     String protocolPath = "/" + geoService.getProtocol().getValue();
 
     if (geoService.getProtocol() == TILES3D) {
       return baseProxyUrl + protocolPath + "/" + GeoServiceProxyController.TILES3D_DESCRIPTION_PATH;
     }
     return baseProxyUrl + protocolPath;
   }
 
   private String getLegendProxyUrl(Application application, AppTreeLayerNode appTreeLayerNode) {
     return linkTo(
             GeoServiceProxyController.class,
             Map.of(
                 "viewerKind",
                 "app",
                 "viewerName",
                 application.getName(),
                 "appLayerId",
                 appTreeLayerNode.getId(),
                 "protocol",
                 PROXIEDLEGEND.getValue()))
         .toString();
   }
 
   private class MapResponseLayerBuilder {
     private final Application app;
     private final MapResponse mr;
     // XXX not needed if we have GeoServiceLayer.getService().getName()
     private final Map<GeoServiceLayer, String> serviceLayerServiceIds = new HashMap<>();
 
     public MapResponseLayerBuilder(Application app, MapResponse mr) {
       this.app = app;
       this.mr = mr;
     }
 
     public void buildLayers() {
       if (app.getContentRoot() != null) {
         buildBackgroundLayers();
         buildOverlayLayers();
         buildTerrainLayers();
       }
     }
 
     private void buildBackgroundLayers() {
       if (app.getContentRoot().getBaseLayerNodes() != null) {
         for (AppTreeNode node : app.getContentRoot().getBaseLayerNodes()) {
           addAppTreeNodeItem(node, mr.getBaseLayerTreeNodes());
         }
       }
     }
 
     private void buildOverlayLayers() {
       if (app.getContentRoot().getLayerNodes() != null) {
         for (AppTreeNode node : app.getContentRoot().getLayerNodes()) {
           addAppTreeNodeItem(node, mr.getLayerTreeNodes());
         }
       }
     }
 
     private void buildTerrainLayers() {
       if (app.getContentRoot().getTerrainLayerNodes() != null) {
         for (AppTreeNode node : app.getContentRoot().getTerrainLayerNodes()) {
           addAppTreeNodeItem(node, mr.getTerrainLayerTreeNodes());
         }
       }
     }
 
     private void addAppTreeNodeItem(AppTreeNode node, List<LayerTreeNode> layerTreeNodeList) {
       LayerTreeNode layerTreeNode = new LayerTreeNode();
       if ("AppTreeLayerNode".equals(node.getObjectType())) {
         AppTreeLayerNode appTreeLayerNode = (AppTreeLayerNode) node;
         layerTreeNode.setId(appTreeLayerNode.getId());
         layerTreeNode.setAppLayerId(appTreeLayerNode.getId());
         if (!addAppLayerItem(appTreeLayerNode)) {
           return;
         }
         // This name is not displayed in the frontend, the title from the appLayer node is used
         layerTreeNode.setName(appTreeLayerNode.getLayerName());
         layerTreeNode.setDescription(appTreeLayerNode.getDescription());
       } else if ("AppTreeLevelNode".equals(node.getObjectType())) {
         AppTreeLevelNode appTreeLevelNode = (AppTreeLevelNode) node;
         layerTreeNode.setId(appTreeLevelNode.getId());
         layerTreeNode.setChildrenIds(appTreeLevelNode.getChildrenIds());
         layerTreeNode.setRoot(Boolean.TRUE.equals(appTreeLevelNode.getRoot()));
         // The name for a level node does show in the frontend
         layerTreeNode.setName(appTreeLevelNode.getTitle());
         layerTreeNode.setDescription(appTreeLevelNode.getDescription());
       }
       layerTreeNodeList.add(layerTreeNode);
     }
 
     private boolean addAppLayerItem(AppTreeLayerNode layerRef) {
       Triple<GeoService, GeoServiceLayer, GeoServiceLayerSettings> serviceWithLayer = findServiceLayer(layerRef);
       GeoService service = serviceWithLayer.getLeft();
       GeoServiceLayer serviceLayer = serviceWithLayer.getMiddle();
 
       if (service == null || serviceLayer == null) {
         return false;
       }
 
       // Some settings can be set on the app layer level, layer level or service level (default
       // layer settings). These settings should be used in-order: from app layer if set, otherwise
       // from layer level, from default layer setting or the default.
 
       // An empty (blank) string means it is not set. To explicitly clear a layer level string
       // setting for an app, an admin should set the app layer setting to spaces.
 
       // The JSON wrapper classes have "null" values as defaults which means not-set. The defaults
       // (such as tilingDisabled being true) are applied below although the frontend would also
       // treat null as non-truthy.
 
       // When default layer settings or settings for a specific layer are missing, construct new
       // settings objects so no null check is needed. All properties are initialized to null
       // (not-set) by default.
       GeoServiceDefaultLayerSettings defaultLayerSettings = Optional.ofNullable(
               service.getSettings().getDefaultLayerSettings())
           .orElseGet(GeoServiceDefaultLayerSettings::new);
       GeoServiceLayerSettings serviceLayerSettings =
           Optional.ofNullable(serviceWithLayer.getRight()).orElseGet(GeoServiceLayerSettings::new);
 
       AppLayerSettings appLayerSettings = app.getAppLayerSettings(layerRef);
 
       String title = Objects.requireNonNullElse(
           nullIfEmpty(appLayerSettings.getTitle()),
           // Get title from layer settings, title from capabilities or the layer name -- never
           // null
           service.getTitleWithSettingsOverrides(layerRef.getLayerName()));
 
       // These settings can be overridden per appLayer
 
       String description = ObjectUtils.firstNonNull(
           nullIfEmpty(appLayerSettings.getDescription()),
           nullIfEmpty(serviceLayerSettings.getDescription()),
           nullIfEmpty(defaultLayerSettings.getDescription()));
 
       String attribution = ObjectUtils.firstNonNull(
           nullIfEmpty(appLayerSettings.getAttribution()),
           nullIfEmpty(serviceLayerSettings.getAttribution()),
           nullIfEmpty(defaultLayerSettings.getAttribution()));
 
       // These settings can't be overridden per appLayer but can be set on a per-layer and
       // service-level default basis
 
       boolean tilingDisabled = ObjectUtils.firstNonNull(
           serviceLayerSettings.getTilingDisabled(), defaultLayerSettings.getTilingDisabled(), true);
       Integer tilingGutter = ObjectUtils.firstNonNull(
           serviceLayerSettings.getTilingGutter(), defaultLayerSettings.getTilingGutter(), 0);
       boolean hiDpiDisabled = ObjectUtils.firstNonNull(
           serviceLayerSettings.getHiDpiDisabled(), defaultLayerSettings.getHiDpiDisabled(), true);
       TileLayerHiDpiMode hiDpiMode = ObjectUtils.firstNonNull(
           serviceLayerSettings.getHiDpiMode(), defaultLayerSettings.getHiDpiMode(), null);
       // Do not get from defaultLayerSettings because a default wouldn't make sense
       String hiDpiSubstituteLayer = serviceLayerSettings.getHiDpiSubstituteLayer();
 
       TMFeatureType tmft = service.findFeatureTypeForLayer(serviceLayer, featureSourceRepository);
 
       boolean proxied = service.getSettings().getUseProxy();
 
       String legendImageUrl = serviceLayerSettings.getLegendImageId();
       if (legendImageUrl == null && serviceLayer.getStyles() != null) {
         // no user defined legend image, try to get legend image from styles
         URI serviceLegendUrl = GeoServiceHelper.getLayerLegendUrlFromStyles(service, serviceLayer);
         legendImageUrl = serviceLegendUrl != null ? serviceLegendUrl.toString() : null;
         if (null != legendImageUrl && proxied) {
           // service styles provides a legend image, but we need to proxy it
           legendImageUrl = getLegendProxyUrl(app, layerRef);
         }
       }
 
       SearchIndex searchIndex = null;
       if (appLayerSettings.getSearchIndexId() != null) {
         searchIndex = searchIndexRepository
             .findById(appLayerSettings.getSearchIndexId())
             .orElse(null);
       }
 
       boolean webMercatorAvailable = this.isWebMercatorAvailable(service, serviceLayer);
 
       mr.addAppLayersItem(new AppLayer()
           .id(layerRef.getId())
           .serviceId(serviceLayerServiceIds.get(serviceLayer))
           .layerName(layerRef.getLayerName())
           .hasAttributes(tmft != null)
           .editable(TMFeatureTypeHelper.isEditable(app, layerRef, tmft))
           .url(proxied ? getProxyUrl(service, app, layerRef) : null)
           // Can't set whether layer is opaque, not mapped from WMS capabilities by GeoTools
           // gt-wms Layer class?
           .maxScale(serviceLayer.getMaxScale())
           .minScale(serviceLayer.getMinScale())
           .title(title)
           .tilingDisabled(tilingDisabled)
           .tilingGutter(tilingGutter)
           .hiDpiDisabled(hiDpiDisabled)
           .hiDpiMode(hiDpiMode)
           .hiDpiSubstituteLayer(hiDpiSubstituteLayer)
           .minZoom(serviceLayerSettings.getMinZoom())
           .maxZoom(serviceLayerSettings.getMaxZoom())
           .tileSize(serviceLayerSettings.getTileSize())
           .tileGridExtent(serviceLayerSettings.getTileGridExtent())
           .opacity(appLayerSettings.getOpacity())
           .autoRefreshInSeconds(appLayerSettings.getAutoRefreshInSeconds())
           .searchIndex(
               searchIndex != null
                   ? new LayerSearchIndex()
                       .id(searchIndex.getId())
                       .name(searchIndex.getName())
                   : null)
           .legendImageUrl(legendImageUrl)
           .visible(layerRef.getVisible())
           .attribution(attribution)
           .description(description)
           .webMercatorAvailable(webMercatorAvailable)
           .hiddenFunctionality(appLayerSettings.getHiddenFunctionality()));
 
       return true;
     }
 
     private Triple<GeoService, GeoServiceLayer, GeoServiceLayerSettings> findServiceLayer(
         AppTreeLayerNode layerRef) {
       GeoService service =
           geoServiceRepository.findById(layerRef.getServiceId()).orElse(null);
       if (service == null) {
         logger.warn(
             "App {} references layer \"{}\" of missing service {}",
             app.getId(),
             layerRef.getLayerName(),
             layerRef.getServiceId());
         return Triple.of(null, null, null);
       }
 
       if (!authorizationService.userMayView(service)) {
         return Triple.of(null, null, null);
       }
 
       if (authorizationService.mustDenyAccessForSecuredProxy(app, service)) {
         return Triple.of(null, null, null);
       }
 
       GeoServiceLayer serviceLayer = service.findLayer(layerRef.getLayerName());
 
       if (serviceLayer == null) {
         logger.warn(
             "App {} references layer \"{}\" not found in capabilities of service {}",
             app.getId(),
             layerRef.getLayerName(),
             service.getId());
         return Triple.of(null, null, null);
       }
 
       if (!authorizationService.userMayView(service, serviceLayer)) {
         return Triple.of(null, null, null);
       }
 
       serviceLayerServiceIds.put(serviceLayer, service.getId());
 
       if (mr.getServices().stream()
           .filter(s -> s.getId().equals(service.getId()))
           .findAny()
           .isEmpty()) {
         mr.addServicesItem(service.toJsonPojo(geoServiceHelper));
       }
 
       GeoServiceLayerSettings layerSettings = service.getLayerSettings(layerRef.getLayerName());
       return Triple.of(service, serviceLayer, layerSettings);
     }
 
     private boolean isWebMercatorAvailable(GeoService service, GeoServiceLayer serviceLayer) {
       if (service.getProtocol() == XYZ) {
         return DEFAULT_WEB_MERCATOR_CRS.equals(service.getSettings().getXyzCrs());
       }
       if (service.getProtocol() == TILES3D || service.getProtocol() == QUANTIZEDMESH) {
         return false;
       }
       while (serviceLayer != null) {
         Set<String> layerCrs = serviceLayer.getCrs();
         if (layerCrs.contains(DEFAULT_WEB_MERCATOR_CRS)) {
           return true;
         }
         if (serviceLayer.getRoot()) {
           break;
         }
         serviceLayer = service.getParentLayer(serviceLayer.getId());
       }
       return false;
     }
   }
 }