/*
    * Themis: Java Project Framework
    * Copyright 2026. Tony Washer
    *
    * 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.
   */
  
  package io.github.tonywasher.joceanus.themis.parser.maven;
  
  import io.github.tonywasher.joceanus.metis.data.MetisDataItem.MetisDataMap;
  import io.github.tonywasher.joceanus.metis.field.MetisFieldItem;
  import io.github.tonywasher.joceanus.metis.field.MetisFieldSet;
  import io.github.tonywasher.joceanus.oceanus.base.OceanusException;
  import io.github.tonywasher.joceanus.oceanus.format.OceanusDataFormatter;
  import io.github.tonywasher.joceanus.themis.exc.ThemisDataException;
  import io.github.tonywasher.joceanus.themis.parser.base.ThemisChar;
  import io.github.tonywasher.joceanus.themis.parser.base.ThemisDataResource;
  
  import java.util.HashMap;
  import java.util.Map;
  
  /**
   * Maven dependency cache.
   */
  public class ThemisMavenVersionCache
          implements MetisDataMap<String, String>, MetisFieldItem {
      /**
       * Report fields.
       */
      private static final MetisFieldSet<ThemisMavenVersionCache> FIELD_DEFS = MetisFieldSet.newFieldSet(ThemisMavenVersionCache.class);
  
      /*
       * Declare Fields.
       */
      static {
          FIELD_DEFS.declareLocalField(ThemisDataResource.DATA_PARENT, ThemisMavenVersionCache::getParent);
      }
  
      /**
       * The map of prefix to version.
       */
      private final Map<String, String> theMap;
  
      /**
       * The parent cache.
       */
      private ThemisMavenVersionCache theParent;
  
      /**
       * Constructor.
       */
      ThemisMavenVersionCache() {
          theMap = new HashMap<>();
      }
  
      @Override
      public MetisFieldSet<ThemisMavenVersionCache> getDataFieldSet() {
          return FIELD_DEFS;
      }
  
      @Override
      public String formatObject(final OceanusDataFormatter pFormatter) {
          return getClass().getSimpleName();
      }
  
      @Override
      public Map<String, String> getUnderlyingMap() {
          return theMap;
      }
  
      /**
       * Obtain the Parent.
       *
       * @return the parent
       */
      private ThemisMavenVersionCache getParent() {
          return theParent;
      }
  
      /**
       * Set the parent cache.
       *
       * @param pParent the parent cache
       */
      void setParent(final ThemisMavenVersionCache pParent) {
          theParent = pParent;
      }
  
      /**
      * Add dependency to cache.
      *
      * @param pId the id to add to the cache
      * @throws OceanusException on error
      */
     public void addToCache(final ThemisMavenId pId) throws OceanusException {
         /* Determine the prefix and the proposed version */
         final String myPrefix = buildPrefix(pId);
         final String myProposed = pId.getVersion();
 
         /* Reject null version */
         if (myProposed == null) {
             throw new ThemisDataException("Proposed version for " + myPrefix + " is null");
         }
 
         /* Update the dependency */
         theMap.put(myPrefix, myProposed);
     }
 
     /**
      * Validate version against cache.
      *
      * @param pId the version to check against cache
      * @return the autoCorrected id.
      * @throws OceanusException on error
      */
     public ThemisMavenId lookUpVersion(final ThemisMavenId pId) throws OceanusException {
         /* Determine the prefix and the proposed version */
         final String myPrefix = buildPrefix(pId);
         final String myProposed = pId.getVersion();
 
         /* Look for existing entry */
         final String myVersion = lookUpVersionInCache(myPrefix);
 
         /* If the prefix is in the cache */
         if (myVersion != null) {
             /* Handle no proposed version */
             if (myProposed == null) {
                 return new ThemisMavenId(pId, myVersion);
 
                 /* Check proposed version is valid */
             } else if (myProposed.equals(myVersion)) {
                 return pId;
 
                 /* Reject conflict */
             } else {
                 throw new ThemisDataException("Conflicting explicit dependency version for " + myPrefix
                         + " Required=" + myVersion
                         + " Proposed=" + myProposed);
             }
 
             /* else prefix is not in cache */
         } else {
             /* Reject if version is unknown */
             if (myProposed == null) {
                 throw new ThemisDataException("Proposed version for " + myPrefix + " is null");
             }
 
             /* Add new dependency and return id */
             theMap.put(myPrefix, pId.getVersion());
             return pId;
         }
     }
 
     /**
      * Import dependencies.
      *
      * @param pChild the child dependency cache
      * @throws OceanusException on error
      */
     void importDependencies(final ThemisMavenVersionCache pChild) throws OceanusException {
         /* Loop through the child entries */
         for (Map.Entry<String, String> myEntry : pChild.getUnderlyingMap().entrySet()) {
             /* Access details */
             final String myPrefix = myEntry.getKey();
             final String myProposed = myEntry.getValue();
 
             /* Look for existing entry */
             final String myVersion = lookUpVersionInCache(myPrefix);
 
             /* Check for mismatch */
             if (myVersion != null && !myVersion.equals(myProposed)) {
                 throw new ThemisDataException("Conflicting imported version for " + myPrefix
                         + " Required=" + myVersion
                         + " Proposed=" + myProposed);
             }
 
             /* Store the entry */
             theMap.put(myPrefix, myProposed);
         }
     }
 
     /**
      * Look up prefix in chain of caches.
      *
      * @param pPrefix the prefix
      * @return the version (or null)
      */
     private String lookUpVersionInCache(final String pPrefix) {
         /* Look for existing entry */
         final String myVersion = theMap.get(pPrefix);
         return (theParent == null || myVersion != null) ? myVersion : theParent.lookUpVersionInCache(pPrefix);
     }
 
     /**
      * Build prefix.
      *
      * @param pId the id
      * @return the prefix
      */
     private String buildPrefix(final ThemisMavenId pId) {
         return pId.getGroupId() + ThemisChar.COLON + pId.getArtifactId();
     }
 }