/* Contributed in the public domain.
    * Licensed to CS GROUP (CS) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * CS licenses this file to You 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 org.orekit.bodies;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.orekit.data.DataProvidersManager;
  import org.orekit.errors.OrekitException;
  import org.orekit.errors.OrekitMessages;
  import org.orekit.frames.Frame;
  import org.orekit.time.TimeScales;
  
  /**
   * This class lazily loads auxiliary data when it is needed by a requested body. It is
   * designed to match the behavior of {@link CelestialBodyFactory} in Orekit 10.0.
   *
   * @author Luc Maisonobe
   * @author Evan Ward
   * @see CelestialBodyFactory
   * @since 10.1
   */
  public class LazyLoadedCelestialBodies implements CelestialBodies {
  
      /** Supplies the auxiliary data files. */
      private final DataProvidersManager dataProvidersManager;
      /** Provides access to time scales when parsing bodies. */
      private final TimeScales timeScales;
      /** Earth centered frame aligned with ICRF. */
      private final Frame gcrf;
      /** Celestial body loaders map. */
      private final Map<String, List<CelestialBodyLoader>> loadersMap = new HashMap<>();
  
      /** Celestial body map. */
      private final Map<String, CelestialBody> celestialBodyMap = new HashMap<>();
  
      /**
       * Create a celestial body factory with the given auxiliary data sources.
       *
       * @param dataProvidersManager supplies JPL ephemerides auxiliary data files.
       * @param timeScales           set of time scales to use when loading bodies.
       * @param gcrf                 Earth centered frame aligned with ICRF.
       */
      public LazyLoadedCelestialBodies(final DataProvidersManager dataProvidersManager,
                                       final TimeScales timeScales,
                                       final Frame gcrf) {
          this.dataProvidersManager = dataProvidersManager;
          this.timeScales = timeScales;
          this.gcrf = gcrf;
      }
  
      /** Add a loader for celestial bodies.
       * @param name name of the body (may be one of the predefined names or a user-defined name)
       * @param loader custom loader to add for the body
       * @see #addDefaultCelestialBodyLoader(String)
       * @see #clearCelestialBodyLoaders(String)
       * @see #clearCelestialBodyLoaders()
       */
      public void addCelestialBodyLoader(final String name,
                                         final CelestialBodyLoader loader) {
          synchronized (loadersMap) {
              loadersMap.computeIfAbsent(name, k -> new ArrayList<>()).add(loader);
          }
      }
  
      /** Add the default loaders for all predefined celestial bodies.
       * @param supportedNames regular expression for supported files names
       * (may be null if the default JPL file names are used)
       * <p>
       * The default loaders look for DE405 or DE406 JPL ephemerides.
       * </p>
       * @see <a href="ftp://ssd.jpl.nasa.gov/pub/eph/planets/Linux/de405/">DE405 JPL ephemerides</a>
       * @see <a href="ftp://ssd.jpl.nasa.gov/pub/eph/planets/Linux/de406/">DE406 JPL ephemerides</a>
       * @see #addCelestialBodyLoader(String, CelestialBodyLoader)
       * @see #addDefaultCelestialBodyLoader(String)
       * @see #clearCelestialBodyLoaders(String)
       * @see #clearCelestialBodyLoaders()
       */
      public void addDefaultCelestialBodyLoader(final String supportedNames) {
          addDefaultCelestialBodyLoader(CelestialBodyFactory.SOLAR_SYSTEM_BARYCENTER, supportedNames);
          addDefaultCelestialBodyLoader(CelestialBodyFactory.SUN,                     supportedNames);
          addDefaultCelestialBodyLoader(CelestialBodyFactory.MERCURY,                 supportedNames);
          addDefaultCelestialBodyLoader(CelestialBodyFactory.VENUS,                   supportedNames);
         addDefaultCelestialBodyLoader(CelestialBodyFactory.EARTH_MOON,              supportedNames);
         addDefaultCelestialBodyLoader(CelestialBodyFactory.EARTH,                   supportedNames);
         addDefaultCelestialBodyLoader(CelestialBodyFactory.MOON,                    supportedNames);
         addDefaultCelestialBodyLoader(CelestialBodyFactory.MARS,                    supportedNames);
         addDefaultCelestialBodyLoader(CelestialBodyFactory.JUPITER,                 supportedNames);
         addDefaultCelestialBodyLoader(CelestialBodyFactory.SATURN,                  supportedNames);
         addDefaultCelestialBodyLoader(CelestialBodyFactory.URANUS,                  supportedNames);
         addDefaultCelestialBodyLoader(CelestialBodyFactory.NEPTUNE,                 supportedNames);
         addDefaultCelestialBodyLoader(CelestialBodyFactory.PLUTO,                   supportedNames);
     }
 
     /** Add the default loaders for celestial bodies.
      * @param name name of the body (if not one of the predefined names, the method does nothing)
      * @param supportedNames regular expression for supported files names
      * (may be null if the default JPL file names are used)
      * <p>
      * The default loaders look for DE405 or DE406 JPL ephemerides.
      * </p>
      * @see <a href="ftp://ssd.jpl.nasa.gov/pub/eph/planets/Linux/de405/">DE405 JPL ephemerides</a>
      * @see <a href="ftp://ssd.jpl.nasa.gov/pub/eph/planets/Linux/de406/">DE406 JPL ephemerides</a>
      * @see #addCelestialBodyLoader(String, CelestialBodyLoader)
      * @see #addDefaultCelestialBodyLoader(String)
      * @see #clearCelestialBodyLoaders(String)
      * @see #clearCelestialBodyLoaders()
      */
     public void addDefaultCelestialBodyLoader(final String name,
                                               final String supportedNames) {
 
         CelestialBodyLoader loader = null;
         if (name.equalsIgnoreCase(CelestialBodyFactory.SOLAR_SYSTEM_BARYCENTER)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.SOLAR_SYSTEM_BARYCENTER, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.SUN)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.SUN, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.MERCURY)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.MERCURY, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.VENUS)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.VENUS, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.EARTH_MOON)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.EARTH_MOON, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.EARTH)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.EARTH, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.MOON)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.MOON, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.MARS)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.MARS, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.JUPITER)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.JUPITER, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.SATURN)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.SATURN, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.URANUS)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.URANUS, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.NEPTUNE)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.NEPTUNE, dataProvidersManager, timeScales, gcrf);
         } else if (name.equalsIgnoreCase(CelestialBodyFactory.PLUTO)) {
             loader =
                     new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.PLUTO, dataProvidersManager, timeScales, gcrf);
         }
 
         if (loader != null) {
             addCelestialBodyLoader(name, loader);
         }
 
     }
 
     /** Clear loaders for one celestial body.
      * <p>
      * Calling this method also clears the celestial body that
      * has been loaded via this {@link CelestialBodyLoader}.
      * </p>
      * @param name name of the body
      * @see #addCelestialBodyLoader(String, CelestialBodyLoader)
      * @see #clearCelestialBodyLoaders()
      * @see #clearCelestialBodyCache(String)
      */
     public void clearCelestialBodyLoaders(final String name) {
         // use same synchronization order as in getBody to prevent deadlocks
         synchronized (celestialBodyMap) {
             // take advantage of reentrent synchronization as
             // clearCelestialBodyCache uses the same lock inside
             clearCelestialBodyCache(name);
 
             synchronized (loadersMap) {
                 loadersMap.remove(name);
             }
         }
     }
 
     /** Clear loaders for all celestial bodies.
      * <p>
      * Calling this method also clears all loaded celestial bodies.
      * </p>
      * @see #addCelestialBodyLoader(String, CelestialBodyLoader)
      * @see #clearCelestialBodyLoaders(String)
      * @see #clearCelestialBodyCache()
      */
     public void clearCelestialBodyLoaders() {
         synchronized (celestialBodyMap) {
             clearCelestialBodyCache();
 
             synchronized (loadersMap) {
                 loadersMap.clear();
             }
         }
     }
 
     /** Clear the specified celestial body from the internal cache.
      * @param name name of the body
      */
     public void clearCelestialBodyCache(final String name) {
         synchronized (celestialBodyMap) {
             celestialBodyMap.remove(name);
         }
     }
 
     /** Clear all loaded celestial bodies.
      * <p>
      * Calling this method will remove all loaded bodies from the internal
      * cache. Subsequent calls to {@link #getBody(String)} or similar methods
      * will result in a reload of the requested body from the configured loader(s).
      * </p>
      */
     public void clearCelestialBodyCache() {
         synchronized (celestialBodyMap) {
             celestialBodyMap.clear();
         }
     }
 
     @Override
     public CelestialBody getSolarSystemBarycenter() {
         return getBody(CelestialBodyFactory.SOLAR_SYSTEM_BARYCENTER);
     }
 
     @Override
     public CelestialBody getSun() {
         return getBody(CelestialBodyFactory.SUN);
     }
 
     @Override
     public CelestialBody getMercury() {
         return getBody(CelestialBodyFactory.MERCURY);
     }
 
     @Override
     public CelestialBody getVenus() {
         return getBody(CelestialBodyFactory.VENUS);
     }
 
     @Override
     public CelestialBody getEarthMoonBarycenter() {
         return getBody(CelestialBodyFactory.EARTH_MOON);
     }
 
     @Override
     public CelestialBody getEarth() {
         return getBody(CelestialBodyFactory.EARTH);
     }
 
     @Override
     public CelestialBody getMoon() {
         return getBody(CelestialBodyFactory.MOON);
     }
 
     @Override
     public CelestialBody getMars() {
         return getBody(CelestialBodyFactory.MARS);
     }
 
     @Override
     public CelestialBody getJupiter() {
         return getBody(CelestialBodyFactory.JUPITER);
     }
 
     @Override
     public CelestialBody getSaturn() {
         return getBody(CelestialBodyFactory.SATURN);
     }
 
     @Override
     public CelestialBody getUranus() {
         return getBody(CelestialBodyFactory.URANUS);
     }
 
     @Override
     public CelestialBody getNeptune() {
         return getBody(CelestialBodyFactory.NEPTUNE);
     }
 
     @Override
     public CelestialBody getPluto() {
         return getBody(CelestialBodyFactory.PLUTO);
     }
 
     /**
      * {@inheritDoc}
      *
      * <p>
      * If no {@link CelestialBodyLoader} has been added by calling {@link
      * #addCelestialBodyLoader(String, CelestialBodyLoader) addCelestialBodyLoader} or if
      * {@link #clearCelestialBodyLoaders(String) clearCelestialBodyLoaders} has been
      * called afterwards, the {@link #addDefaultCelestialBodyLoader(String, String)
      * addDefaultCelestialBodyLoader} method will be called automatically, once with the
      * default name for JPL DE ephemerides and once with the default name for IMCCE INPOP
      * files.
      * </p>
      */
     @Override
     public CelestialBody getBody(final String name) {
         synchronized (celestialBodyMap) {
             CelestialBody body = celestialBodyMap.get(name);
             if (body == null) {
                 synchronized (loadersMap) {
                     List<CelestialBodyLoader> loaders = loadersMap.get(name);
                     if (loaders == null || loaders.isEmpty()) {
                         addDefaultCelestialBodyLoader(name, JPLEphemeridesLoader.DEFAULT_DE_SUPPORTED_NAMES);
                         addDefaultCelestialBodyLoader(name, JPLEphemeridesLoader.DEFAULT_INPOP_SUPPORTED_NAMES);
                         loaders = loadersMap.get(name);
                     }
                     OrekitException delayedException = null;
                     for (CelestialBodyLoader loader : loaders) {
                         try {
                             body = loader.loadCelestialBody(name);
                             if (body != null) {
                                 break;
                             }
                         } catch (OrekitException oe) {
                             delayedException = oe;
                         }
                     }
                     if (body == null) {
                         throw (delayedException != null) ?
                                 delayedException :
                                 new OrekitException(OrekitMessages.NO_DATA_LOADED_FOR_CELESTIAL_BODY, name);
                     }
 
                 }
 
                 // save the body
                 celestialBodyMap.put(name, body);
 
             }
 
             return body;
 
         }
     }
 
 }