/* 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.files.ccsds.ndm.odm.opm;
  
  import java.util.Arrays;
  
  import org.hipparchus.geometry.euclidean.threed.Vector3D;
  import org.orekit.files.ccsds.definitions.FrameFacade;
  import org.orekit.files.ccsds.section.CommentsContainer;
  import org.orekit.time.AbsoluteDate;
  
  /** Maneuver in an OPM file.
   * <p>
   * Beware that the Orekit getters and setters all rely on SI units. The parsers
   * and writers take care of converting these SI units into CCSDS mandatory units.
   * The {@link org.orekit.utils.units.Unit Unit} class provides useful
   * {@link org.orekit.utils.units.Unit#fromSI(double) fromSi} and
   * {@link org.orekit.utils.units.Unit#toSI(double) toSI} methods in case the callers
   * already use CCSDS units instead of the API SI units. The general-purpose
   * {@link org.orekit.utils.units.Unit Unit} class (without an 's') and the
   * CCSDS-specific {@link org.orekit.files.ccsds.definitions.Units Units} class
   * (with an 's') also provide some predefined units. These predefined units and the
   * {@link org.orekit.utils.units.Unit#fromSI(double) fromSi} and
   * {@link org.orekit.utils.units.Unit#toSI(double) toSI} conversion methods are indeed
   * what the parsers and writers use for the conversions.
   * </p>
   * @author sports
   * @since 6.1
   */
  public class Maneuver extends CommentsContainer {
  
      /** Epoch ignition. */
      private AbsoluteDate epochIgnition;
  
      /** Coordinate system for velocity increment vector, for absolute frames. */
      private FrameFacade referenceFrame;
  
      /** Duration (value is 0 for impulsive maneuver). */
      private double duration;
  
      /** Mass change during maneuver (value is < 0). */
      private double deltaMass;
  
      /** Velocity increment. */
      private final double[] dV;
  
      /** Simple constructor.
       */
      public Maneuver() {
          duration  = Double.NaN;
          deltaMass = Double.NaN;
          dV        = new double[3];
          Arrays.fill(dV, Double.NaN);
      }
  
      /** {@inheritDoc} */
      @Override
      public void validate(final double version) {
          super.validate(version);
          checkNotNull(epochIgnition,  ManeuverKey.MAN_EPOCH_IGNITION.name());
          checkNotNull(referenceFrame, ManeuverKey.MAN_REF_FRAME.name());
          checkNotNaN(duration,        ManeuverKey.MAN_DURATION.name());
          checkNotNaN(deltaMass,       ManeuverKey.MAN_DELTA_MASS.name());
          checkNotNaN(dV[0],           ManeuverKey.MAN_DV_1.name());
          checkNotNaN(dV[1],           ManeuverKey.MAN_DV_2.name());
          checkNotNaN(dV[2],           ManeuverKey.MAN_DV_3.name());
      }
  
      /** Get epoch ignition.
       * @return epoch ignition
       */
      public AbsoluteDate getEpochIgnition() {
          return epochIgnition;
      }
  
      /** Set epoch ignition.
       * @param epochIgnition epoch ignition
       */
      public void setEpochIgnition(final AbsoluteDate epochIgnition) {
          this.epochIgnition = epochIgnition;
      }
  
      /** Get Coordinate system for velocity increment vector.
       * @return coordinate system for velocity increment vector
      */
     public FrameFacade getReferenceFrame() {
         return referenceFrame;
     }
 
     /** Set Coordinate system for velocity increment vector.
      * @param referenceFrame coordinate system for velocity increment vector
      */
     public void setReferenceFrame(final FrameFacade referenceFrame) {
         this.referenceFrame = referenceFrame;
     }
 
     /** Get duration (value is 0 for impulsive maneuver).
      * @return duration (value is 0 for impulsive maneuver)
      */
     public double getDuration() {
         return duration;
     }
 
     /** Set duration (value is 0 for impulsive maneuver).
      * @param duration duration (value is 0 for impulsive maneuver)
      */
     public void setDuration(final double duration) {
         this.duration = duration;
     }
 
     /** Get mass change during maneuver (value is &lt; 0).
      * @return mass change during maneuver (value is &lt; 0)
      */
     public double getDeltaMass() {
         return deltaMass;
     }
 
     /** Set mass change during maneuver (value is &lt; 0).
      * @param deltaMass mass change during maneuver (value is &lt; 0)
      */
     public void setDeltaMass(final double deltaMass) {
         this.deltaMass = deltaMass;
     }
 
     /** Get velocity increment.
      * @return velocity increment
      */
     public Vector3D getDV() {
         return new Vector3D(dV);
     }
 
     /** Set velocity increment component.
      * @param i component index
      * @param dVi velocity increment component
      */
     public void setDV(final int i, final double dVi) {
         dV[i] = dVi;
     }
 
     /** Check if maneuver has been completed.
      * @return true if maneuver has been completed
      */
     public boolean completed() {
         return !(epochIgnition == null ||
                  referenceFrame == null ||
                  Double.isNaN(duration + deltaMass + dV[0] + dV[1] + dV[2]));
     }
 
 }