/* Copyright 2002-2026 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.utils;
  
  
  import org.hipparchus.CalculusFieldElement;
  import org.hipparchus.Field;
  import org.hipparchus.analysis.differentiation.DerivativeStructure;
  import org.hipparchus.analysis.differentiation.FieldDerivative;
  import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  import org.orekit.annotation.DefaultDataContext;
  import org.orekit.errors.OrekitIllegalArgumentException;
  import org.orekit.errors.OrekitMessages;
  import org.orekit.frames.Frame;
  import org.orekit.time.FieldAbsoluteDate;
  import org.orekit.time.TimeOffset;
  
  /** Field implementation of AbsolutePVCoordinates.
   * @see AbsolutePVCoordinates
   * @author Vincent Mouraux
   * @param <T> type of the field elements
   */
  public class FieldAbsolutePVCoordinates<T extends CalculusFieldElement<T>>
      implements ShiftableFieldPVCoordinatesHolder<FieldAbsolutePVCoordinates<T>, T> {
  
      /** Frame in which are defined the coordinates. */
      private final Frame frame;
  
      /** Position-velocity-acceleration vector. */
      private final TimeStampedFieldPVCoordinates<T> timeStampedFieldPVCoordinates;
  
      /** Build from position, velocity, acceleration.
       * @param frame the frame in which the coordinates are defined
       * @param date coordinates date
       * @param position the position vector (m)
       * @param velocity the velocity vector (m/s)
       * @param acceleration the acceleration vector (m/sÂý)
       */
      public FieldAbsolutePVCoordinates(final Frame frame, final FieldAbsoluteDate<T> date,
                                        final FieldVector3D<T> position, final FieldVector3D<T> velocity,
                                        final FieldVector3D<T> acceleration) {
          this(frame, new TimeStampedFieldPVCoordinates<>(date, position, velocity, acceleration));
      }
  
      /** Build from position and velocity. Acceleration is set to zero.
       * @param frame the frame in which the coordinates are defined
       * @param date coordinates date
       * @param position the position vector (m)
       * @param velocity the velocity vector (m/s)
       */
      public FieldAbsolutePVCoordinates(final Frame frame, final FieldAbsoluteDate<T> date,
                                        final FieldVector3D<T> position, final FieldVector3D<T> velocity) {
          this(frame, date, position, velocity, FieldVector3D.getZero(date.getField()));
      }
  
      /** Build from frame, date and FieldPVA coordinates.
       * @param frame the frame in which the coordinates are defined
       * @param date date of the coordinates
       * @param pva TimeStampedPVCoordinates
       */
      public FieldAbsolutePVCoordinates(final Frame frame, final FieldAbsoluteDate<T> date, final FieldPVCoordinates<T> pva) {
          this(frame, new TimeStampedFieldPVCoordinates<>(date, pva));
      }
  
      /** Build from frame and TimeStampedFieldPVCoordinates.
       * @param frame the frame in which the coordinates are defined
       * @param pva TimeStampedFieldPVCoordinates
       */
      public FieldAbsolutePVCoordinates(final Frame frame, final TimeStampedFieldPVCoordinates<T> pva) {
          this.timeStampedFieldPVCoordinates = pva;
          this.frame = frame;
      }
  
      /** Build from Field and non-Fielded object.
       * @param field field
       * @param pva non-Field AbsolutePVCoordinates
       */
      public FieldAbsolutePVCoordinates(final Field<T> field, final AbsolutePVCoordinates pva) {
          this(pva.getFrame(), new TimeStampedFieldPVCoordinates<>(field, pva.getPVCoordinates()));
      }
  
      /** Multiplicative constructor
       * <p>Build a FieldAbsolutePVCoordinates from another one and a scale factor.</p>
       * <p>The TimeStampedFieldPVCoordinates built will be a * AbsPva</p>
       * @param date date of the built coordinates
      * @param a scale factor
      * @param absPva base (unscaled) FieldAbsolutePVCoordinates
      */
     public FieldAbsolutePVCoordinates(final FieldAbsoluteDate<T> date, final T a,
                                       final FieldAbsolutePVCoordinates<T> absPva) {
         this(absPva.getFrame(), new TimeStampedFieldPVCoordinates<>(date, a, absPva.getPVCoordinates()));
     }
 
     /** Subtractive constructor
      * <p>Build a relative FieldAbsolutePVCoordinates from a start and an end position.</p>
      * <p>The FieldAbsolutePVCoordinates built will be end - start.</p>
      * <p>In case start and end use two different pseudo-inertial frames,
      * the new FieldAbsolutePVCoordinates arbitrarily be defined in the start frame. </p>
      * @param date date of the built coordinates
      * @param start Starting FieldAbsolutePVCoordinates
      * @param end ending FieldAbsolutePVCoordinates
      */
     public FieldAbsolutePVCoordinates(final FieldAbsoluteDate<T> date, final FieldAbsolutePVCoordinates<T> start,
                                       final FieldAbsolutePVCoordinates<T> end) {
         this(start.getFrame(), new TimeStampedFieldPVCoordinates<>(date, start.getPVCoordinates(), end.getPVCoordinates()));
         ensureIdenticalFrames(start, end);
     }
 
     /** Linear constructor
      * <p>Build a FieldAbsolutePVCoordinates from two other ones and corresponding scale factors.</p>
      * <p>The FieldAbsolutePVCoordinates built will be a1 * u1 + a2 * u2</p>
      * <p>In case the FieldAbsolutePVCoordinates use different pseudo-inertial frames,
      * the new FieldAbsolutePVCoordinates arbitrarily be defined in the first frame. </p>
      * @param date date of the built coordinates
      * @param a1 first scale factor
      * @param absPv1 first base (unscaled) FieldAbsolutePVCoordinates
      * @param a2 second scale factor
      * @param absPv2 second base (unscaled) FieldAbsolutePVCoordinates
      */
     public FieldAbsolutePVCoordinates(final FieldAbsoluteDate<T> date,
                                       final T a1, final FieldAbsolutePVCoordinates<T> absPv1,
                                       final T a2, final FieldAbsolutePVCoordinates<T> absPv2) {
         this(absPv1.getFrame(), new TimeStampedFieldPVCoordinates<>(date, a1, absPv1.getPVCoordinates(), a2, absPv2.getPVCoordinates()));
         ensureIdenticalFrames(absPv1, absPv2);
     }
 
     /** Linear constructor
      * <p>Build a FieldAbsolutePVCoordinates from three other ones and corresponding scale factors.</p>
      * <p>The FieldAbsolutePVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
      * <p>In case the FieldAbsolutePVCoordinates use different pseudo-inertial frames,
      * the new FieldAbsolutePVCoordinates arbitrarily be defined in the first frame. </p>
      * @param date date of the built coordinates
      * @param a1 first scale factor
      * @param absPv1 first base (unscaled) FieldAbsolutePVCoordinates
      * @param a2 second scale factor
      * @param absPv2 second base (unscaled) FieldAbsolutePVCoordinates
      * @param a3 third scale factor
      * @param absPv3 third base (unscaled) FieldAbsolutePVCoordinates
      */
     public FieldAbsolutePVCoordinates(final FieldAbsoluteDate<T> date,
                                       final T a1, final FieldAbsolutePVCoordinates<T> absPv1,
                                       final T a2, final FieldAbsolutePVCoordinates<T> absPv2,
                                       final T a3, final FieldAbsolutePVCoordinates<T> absPv3) {
         this(absPv1.getFrame(), new TimeStampedFieldPVCoordinates<>(date, a1, absPv1.getPVCoordinates(), a2,
                 absPv2.getPVCoordinates(), a3, absPv3.getPVCoordinates()));
 
         ensureIdenticalFrames(absPv1, absPv2);
         ensureIdenticalFrames(absPv1, absPv3);
     }
 
     /** Linear constructor
      * <p>Build a FieldAbsolutePVCoordinates from four other ones and corresponding scale factors.</p>
      * <p>The FieldAbsolutePVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4</p>
      * <p>In case the FieldAbsolutePVCoordinates use different pseudo-inertial frames,
      * the new AbsolutePVCoordinates arbitrarily be defined in the first frame. </p>
      * @param date date of the built coordinates
      * @param a1 first scale factor
      * @param absPv1 first base (unscaled) FieldAbsolutePVCoordinates
      * @param a2 second scale factor
      * @param absPv2 second base (unscaled) FieldAbsolutePVCoordinates
      * @param a3 third scale factor
      * @param absPv3 third base (unscaled) FieldAbsolutePVCoordinates
      * @param a4 fourth scale factor
      * @param absPv4 fourth base (unscaled) FieldAbsolutePVCoordinates
      */
     public FieldAbsolutePVCoordinates(final FieldAbsoluteDate<T> date,
                                  final T a1, final FieldAbsolutePVCoordinates<T> absPv1,
                                  final T a2, final FieldAbsolutePVCoordinates<T> absPv2,
                                  final T a3, final FieldAbsolutePVCoordinates<T> absPv3,
                                  final T a4, final FieldAbsolutePVCoordinates<T> absPv4) {
         this(absPv1.getFrame(), new TimeStampedFieldPVCoordinates<>(date, a1, absPv1.getPVCoordinates(), a2,
                 absPv2.getPVCoordinates(), a3, absPv3.getPVCoordinates(), a4, absPv4.getPVCoordinates()));
         ensureIdenticalFrames(absPv1, absPv2);
         ensureIdenticalFrames(absPv1, absPv3);
         ensureIdenticalFrames(absPv1, absPv4);
     }
 
     /** Builds a FieldAbsolutePVCoordinates triplet from  a {@link FieldVector3D}&lt;{@link DerivativeStructure}&gt;.
      * <p>
      * The vector components must have time as their only derivation parameter and
      * have consistent derivation orders.
      * </p>
      * @param frame the frame in which the parameters are defined
      * @param date date of the built coordinates
      * @param p vector with time-derivatives embedded within the coordinates
      * @param <U> type of the derivative
      */
     public <U extends FieldDerivative<T, U>> FieldAbsolutePVCoordinates(final Frame frame, final FieldAbsoluteDate<T> date,
                                                                         final FieldVector3D<U> p) {
         this(frame, new TimeStampedFieldPVCoordinates<>(date, p));
     }
 
     /** Ensure that the frames from two FieldAbsolutePVCoordinates are identical.
      * @param absPv1 first FieldAbsolutePVCoordinates
      * @param absPv2 first FieldAbsolutePVCoordinates
      * @param <T> the type of the field elements
      * @throws OrekitIllegalArgumentException if frames are different
      */
     private static <T extends CalculusFieldElement<T>> void ensureIdenticalFrames(final FieldAbsolutePVCoordinates<T> absPv1, final FieldAbsolutePVCoordinates<T> absPv2)
         throws OrekitIllegalArgumentException {
         if (!absPv1.frame.equals(absPv2.frame)) {
             throw new OrekitIllegalArgumentException(OrekitMessages.INCOMPATIBLE_FRAMES,
                                                      absPv1.frame.getName(), absPv2.frame.getName());
         }
     }
 
     /** Get a time-shifted state.
      * <p>
      * The state can be slightly shifted to close dates. This shift is based on
      * a simple Taylor expansion. It is <em>not</em> intended as a replacement for
      * proper orbit propagation (it is not even Keplerian!) but should be sufficient
      * for either small time shifts or coarse accuracy.
      * </p>
      * @param dt time shift in seconds
      * @return a new state, shifted with respect to the instance (which is immutable)
      */
     @Override
     public FieldAbsolutePVCoordinates<T> shiftedBy(final T dt) {
         final TimeStampedFieldPVCoordinates<T> spv = timeStampedFieldPVCoordinates.shiftedBy(dt);
         return new FieldAbsolutePVCoordinates<>(frame, spv);
     }
 
     @Override
     public FieldAbsolutePVCoordinates<T> shiftedBy(final TimeOffset dt) {
         final TimeStampedFieldPVCoordinates<T> spv = timeStampedFieldPVCoordinates.shiftedBy(dt);
         return new FieldAbsolutePVCoordinates<>(frame, spv);
     }
 
     /** Get a time-shifted state.
      * <p>
      * The state can be slightly shifted to close dates. This shift is based on
      * a simple Taylor expansion. It is <em>not</em> intended as a replacement for
      * proper orbit propagation (it is not even Keplerian!) but should be sufficient
      * for either small time shifts or coarse accuracy.
      * </p>
      * @param dt time shift in seconds
      * @return a new state, shifted with respect to the instance (which is immutable)
      */
     @Override
     public FieldAbsolutePVCoordinates<T> shiftedBy(final double dt) {
         final TimeStampedFieldPVCoordinates<T> spv = timeStampedFieldPVCoordinates.shiftedBy(dt);
         return new FieldAbsolutePVCoordinates<>(frame, spv);
     }
 
     /** Create a local provider using simply Taylor expansion through {@link #shiftedBy(double)}.
      * <p>
      * The time evolution is based on a simple Taylor expansion. It is <em>not</em> intended as a
      * replacement for proper orbit propagation (it is not even Keplerian!) but should be sufficient
      * for either small time shifts or coarse accuracy.
      * </p>
      * @return provider based on Taylor expansion, for small time shifts around instance date
      */
     public FieldPVCoordinatesProvider<T> toTaylorProvider() {
         return this;
     }
 
     /** {@inheritDoc} */
     @Override
     public FieldAbsoluteDate<T> getDate() {
         return timeStampedFieldPVCoordinates.getDate();
     }
 
     /** Get the frame in which the coordinates are defined.
      * @return frame in which the coordinates are defined
      */
     public Frame getFrame() {
         return frame;
     }
 
     /** Get the TimeStampedFieldPVCoordinates.
      * @return TimeStampedFieldPVCoordinates
      */
     public TimeStampedFieldPVCoordinates<T> getPVCoordinates() {
         return timeStampedFieldPVCoordinates;
     }
 
     /**
      * Getter for the acceleration vector.
      * @return acceleration
      */
     public FieldVector3D<T> getAcceleration() {
         return timeStampedFieldPVCoordinates.getAcceleration();
     }
 
     /** {@inheritDoc} */
     @Override
     public FieldVector3D<T> getPosition(final FieldAbsoluteDate<T> otherDate, final Frame outputFrame) {
         final T duration = otherDate.durationFrom(getDate());
         final FieldVector3D<T> position = getPosition().add((getVelocity().add(getAcceleration().scalarMultiply(duration.divide(2)))).scalarMultiply(duration));
 
         if (outputFrame == frame) {
             return position;
         }
         return frame.getStaticTransformTo(frame, otherDate).transformPosition(position);
     }
 
     /**
      * Converts to an AbsolutePVCoordinates instance.
      * @return AbsolutePVCoordinates with same properties
      */
     public AbsolutePVCoordinates toAbsolutePVCoordinates() {
         return new AbsolutePVCoordinates(frame, timeStampedFieldPVCoordinates.toTimeStampedPVCoordinates());
     }
 
     /** {@inheritDoc} */
     @Override
     @DefaultDataContext
     public String toString() {
         return timeStampedFieldPVCoordinates.toString();
     }
 }