/* Copyright 2002-2025 CS GROUP
    * 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.frames;
  
  import java.util.concurrent.atomic.AtomicReference;
  
  import org.hipparchus.CalculusFieldElement;
  import org.orekit.time.AbsoluteDate;
  import org.orekit.time.FieldAbsoluteDate;
  import org.orekit.time.TimeScale;
  
  
  /** Provider for a specific version of International Terrestrial Reference Frame.
   * <p>
   * This class ensure the ITRF it defines is a specific version, regardless of
   * the version of the underlying {@link EOPEntry Earth Orientation Parameters}.
   * </p>
   * @author Luc Maisonobe
   * @since 9.2
   */
  class VersionedITRFProvider implements EOPBasedTransformProvider {
  
      /** ITRF version this provider should generate. */
      private final ITRFVersion version;
  
      /** Raw ITRF provider. */
      private final ITRFProvider rawProvider;
  
      /** Converter between different ITRF versions. */
      private final AtomicReference<ITRFVersion.Converter> converter;
  
      /** TT time scale. */
      private final TimeScale tt;
  
      /** Simple constructor.
       * @param version ITRF version this provider should generate
       * @param rawProvider raw ITRF provider
       * @param tt TT time scale.
       */
      VersionedITRFProvider(final ITRFVersion version,
                            final ITRFProvider rawProvider,
                            final TimeScale tt) {
          this.version     = version;
          this.rawProvider = rawProvider;
          this.converter   = new AtomicReference<>();
          this.tt = tt;
      }
  
      /** Get the ITRF version.
       * @return ITRF version
       */
      public ITRFVersion getITRFVersion() {
          return version;
      }
  
      /** {@inheritDoc} */
      @Override
      public EOPHistory getEOPHistory() {
          return rawProvider.getEOPHistory();
      }
  
      /** {@inheritDoc} */
      @Override
      public VersionedITRFProvider getNonInterpolatingProvider() {
          return new VersionedITRFProvider(version, rawProvider.getNonInterpolatingProvider(), tt);
      }
  
      /** {@inheritDoc} */
      @Override
      public Transform getTransform(final AbsoluteDate date) {
  
          // get the transform from the current EOP
          final Transform rawTransform = rawProvider.getTransform(date);
  
          // add the conversion layer
          final ITRFVersion.Converter converterForDate = getConverter(date);
          if (converterForDate == null) {
              return rawTransform;
          } else {
              return new Transform(date, rawTransform, converterForDate.getTransform(date));
          }
  
      }
  
      /** {@inheritDoc} */
     @Override
     public KinematicTransform getKinematicTransform(final AbsoluteDate date) {
 
         // get the transform from the current EOP
         final KinematicTransform rawTransform = rawProvider.getKinematicTransform(date);
 
         // add the conversion layer
         final ITRFVersion.Converter converterForDate = getConverter(date);
         if (converterForDate == null) {
             return rawTransform;
         } else {
             return KinematicTransform.compose(date, rawTransform, converterForDate.getKinematicTransform(date));
         }
 
     }
 
     /** {@inheritDoc} */
     @Override
     public StaticTransform getStaticTransform(final AbsoluteDate date) {
 
         // get the transform from the current EOP
         final StaticTransform rawTransform = rawProvider.getStaticTransform(date);
 
         // add the conversion layer
         final ITRFVersion.Converter converterForDate = getConverter(date);
         if (converterForDate == null) {
             return rawTransform;
         } else {
             return StaticTransform.compose(
                     date,
                     rawTransform,
                     converterForDate.getStaticTransform(date));
         }
 
     }
 
     /** {@inheritDoc} */
     @Override
     public <T extends CalculusFieldElement<T>> FieldTransform<T> getTransform(final FieldAbsoluteDate<T> date) {
 
         // get the transform from the current EOP
         final FieldTransform<T> rawTransform = rawProvider.getTransform(date);
 
         // add the conversion layer
         final ITRFVersion.Converter converterForDate = getConverter(date.toAbsoluteDate());
         if (converterForDate == null) {
             return rawTransform;
         } else {
             return new FieldTransform<>(date, rawTransform, converterForDate.getTransform(date));
         }
 
     }
 
     /** {@inheritDoc} */
     @Override
     public <T extends CalculusFieldElement<T>> FieldKinematicTransform<T> getKinematicTransform(final FieldAbsoluteDate<T> date) {
 
         // get the transform from the current EOP
         final FieldKinematicTransform<T> rawTransform = rawProvider.getKinematicTransform(date);
 
         // add the conversion layer
         final ITRFVersion.Converter converterForDate = getConverter(date.toAbsoluteDate());
         if (converterForDate == null) {
             return rawTransform;
         } else {
             return FieldKinematicTransform.compose(date, rawTransform, converterForDate.getKinematicTransform(date));
         }
 
     }
 
     /** {@inheritDoc} */
     @Override
     public <T extends CalculusFieldElement<T>> FieldStaticTransform<T> getStaticTransform(final FieldAbsoluteDate<T> date) {
 
         // get the transform from the current EOP
         final FieldStaticTransform<T> rawTransform = rawProvider.getStaticTransform(date);
 
         // add the conversion layer
         final ITRFVersion.Converter converterForDate = getConverter(date.toAbsoluteDate());
         if (converterForDate == null) {
             return rawTransform;
         } else {
             return FieldStaticTransform.compose(
                     date,
                     rawTransform,
                     converterForDate.getStaticTransform(date));
         }
 
     }
 
     /** Get a converter for the date.
      * @param date date to check
      * @return converter that should be applied for this date, or null
      * if no converter is needed
      */
     private ITRFVersion.Converter getConverter(final AbsoluteDate date) {
 
         // check if the current EOP already provides the version we want
         final ITRFVersion rawVersion = getEOPHistory().getITRFVersion(date);
         if (rawVersion == version) {
             // we already have what we need
             return null;
         }
 
         final ITRFVersion.Converter existing = converter.get();
         if (existing != null && existing.getOrigin() == rawVersion) {
             // the current converter can handle this date
             return existing;
         }
 
         // we need to create a new converter from raw version to desired version
         final ITRFVersion.Converter newConverter =
                 ITRFVersion.getConverter(rawVersion, version, tt);
         converter.compareAndSet(null, newConverter);
         return newConverter;
 
     }
 
 }