/* Copyright 2002-2024 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.forces.maneuvers;
  
  import org.hipparchus.geometry.euclidean.threed.Rotation;
  import org.hipparchus.geometry.euclidean.threed.Vector3D;
  import org.hipparchus.ode.events.Action;
  import org.hipparchus.util.FastMath;
  import org.orekit.attitudes.AttitudeProvider;
  import org.orekit.orbits.CartesianOrbit;
  import org.orekit.propagation.SpacecraftState;
  import org.orekit.propagation.events.AbstractDetector;
  import org.orekit.propagation.events.AdaptableInterval;
  import org.orekit.propagation.events.EventDetector;
  import org.orekit.propagation.events.handlers.EventHandler;
  import org.orekit.time.AbsoluteDate;
  import org.orekit.utils.Constants;
  import org.orekit.utils.DoubleArrayDictionary;
  import org.orekit.utils.PVCoordinates;
  
  /** Impulse maneuver model.
   * <p>This class implements an impulse maneuver as a discrete event
   * that can be provided to any {@link org.orekit.propagation.Propagator
   * Propagator}.</p>
   * <p>The maneuver is triggered when an underlying event generates a
   * {@link Action#STOP STOP} event, in which case this class will generate a {@link
   * Action#RESET_STATE RESET_STATE}
   * event (the stop event from the underlying object is therefore filtered out).
   * In the simple cases, the underlying event detector may be a basic
   * {@link org.orekit.propagation.events.DateDetector date event}, but it
   * can also be a more elaborate {@link
   * org.orekit.propagation.events.ApsideDetector apside event} for apogee
   * maneuvers for example.</p>
   * <p>The maneuver is defined by a single velocity increment.
   * If no AttitudeProvider is given, the current attitude of the spacecraft,
   * defined by the current spacecraft state, will be used as the
   * {@link AttitudeProvider} so the velocity increment should be given in
   * the same pseudoinertial frame as the {@link SpacecraftState} used to
   * construct the propagator that will handle the maneuver.
   * If an AttitudeProvider is given, the velocity increment given should be
   * defined appropriately in consideration of that provider. So, a typical
   * case for tangential maneuvers is to provide a {@link org.orekit.attitudes.LofOffset LOF aligned}
   * attitude provider along with a velocity increment defined in accordance with
   * that LOF aligned attitude provider; e.g. if the LOF aligned attitude provider
   * was constructed using LOFType.VNC the velocity increment should be
   * provided in VNC coordinates.</p>
   * <p>The norm through which the delta-V maps to the mass consumption is chosen via the
   * enum {@link Control3DVectorCostType}. Default is Euclidean. </p>
   * <p>Beware that the triggering event detector must behave properly both
   * before and after maneuver. If for example a node detector is used to trigger
   * an inclination maneuver and the maneuver change the orbit to an equatorial one,
   * the node detector will fail just after the maneuver, being unable to find a
   * node on an equatorial orbit! This is a real case that has been encountered
   * during validation ...</p>
   * @see org.orekit.propagation.Propagator#addEventDetector(EventDetector)
   * @author Luc Maisonobe
   */
  public class ImpulseManeuver extends AbstractDetector<ImpulseManeuver> {
  
      /** The attitude to override during the maneuver, if set. */
      private final AttitudeProvider attitudeOverride;
  
      /** Triggering event. */
      private final EventDetector trigger;
  
      /** Velocity increment in satellite frame. */
      private final Vector3D deltaVSat;
  
      /** Specific impulse. */
      private final double isp;
  
      /** Engine exhaust velocity. */
      private final double vExhaust;
  
      /** Indicator for forward propagation. */
      private boolean forward;
  
      /** Type of norm linking delta-V to mass consumption. */
      private final Control3DVectorCostType control3DVectorCostType;
  
      /** Build a new instance.
       * @param trigger triggering event
       * @param deltaVSat velocity increment in satellite frame
       * @param isp engine specific impulse (s)
       */
     public ImpulseManeuver(final EventDetector trigger, final Vector3D deltaVSat, final double isp) {
         this(trigger, null, deltaVSat, isp);
     }
 
 
     /** Build a new instance.
      * @param trigger triggering event
      * @param attitudeOverride the attitude provider to use for the maneuver
      * @param deltaVSat velocity increment in satellite frame
      * @param isp engine specific impulse (s)
      */
     public ImpulseManeuver(final EventDetector trigger, final AttitudeProvider attitudeOverride,
                            final Vector3D deltaVSat, final double isp) {
         this(trigger.getMaxCheckInterval(), trigger.getThreshold(),
              trigger.getMaxIterationCount(), new Handler(),
              trigger, attitudeOverride, deltaVSat, isp, Control3DVectorCostType.TWO_NORM);
     }
 
     /** Build a new instance.
      * @param trigger triggering event
      * @param attitudeOverride the attitude provider to use for the maneuver
      * @param deltaVSat velocity increment in satellite frame
      * @param isp engine specific impulse (s)
      * @param control3DVectorCostType increment's norm for mass consumption
      */
     public ImpulseManeuver(final EventDetector trigger, final AttitudeProvider attitudeOverride,
                            final Vector3D deltaVSat, final double isp, final Control3DVectorCostType control3DVectorCostType) {
         this(trigger.getMaxCheckInterval(), trigger.getThreshold(),
              trigger.getMaxIterationCount(), new Handler(),
              trigger, attitudeOverride, deltaVSat, isp, control3DVectorCostType);
     }
 
     /** Protected constructor with full parameters.
      * <p>
      * This constructor is not public as users are expected to use the builder
      * API with the various {@code withXxx()} methods to set up the instance
      * in a readable manner without using a huge amount of parameters.
      * </p>
      * @param maxCheck maximum checking interval
      * @param threshold convergence threshold (s)
      * @param maxIter maximum number of iterations in the event time search
      * @param handler event handler to call at event occurrences
      * @param trigger triggering event
      * @param attitudeOverride the attitude provider to use for the maneuver
      * @param deltaVSat velocity increment in satellite frame
      * @param isp engine specific impulse (s)
      * @param control3DVectorCostType increment's norm for mass consumption
      * @since 6.1
      */
     protected ImpulseManeuver(final AdaptableInterval maxCheck, final double threshold,
                               final int maxIter, final EventHandler handler,
                               final EventDetector trigger, final AttitudeProvider attitudeOverride, final Vector3D deltaVSat,
                               final double isp, final Control3DVectorCostType control3DVectorCostType) {
         super(maxCheck, threshold, maxIter, handler);
         this.attitudeOverride = attitudeOverride;
         this.trigger   = trigger;
         this.deltaVSat = deltaVSat;
         this.isp       = isp;
         this.vExhaust  = Constants.G0_STANDARD_GRAVITY * isp;
         this.control3DVectorCostType = control3DVectorCostType;
     }
 
     /** {@inheritDoc} */
     @Override
     protected ImpulseManeuver create(final AdaptableInterval newMaxCheck, final double newThreshold,
                                      final int newMaxIter, final EventHandler newHandler) {
         return new ImpulseManeuver(newMaxCheck, newThreshold, newMaxIter, newHandler,
                                    trigger, attitudeOverride, deltaVSat, isp, control3DVectorCostType);
     }
 
     /** {@inheritDoc} */
     public void init(final SpacecraftState s0, final AbsoluteDate t) {
         forward = t.durationFrom(s0.getDate()) >= 0;
         // Initialize the triggering event
         trigger.init(s0, t);
     }
 
     /** {@inheritDoc} */
     public double g(final SpacecraftState s) {
         return trigger.g(s);
     }
 
     /**
      * Get the Attitude Provider to use during maneuver.
      * @return the attitude provider
      */
     public AttitudeProvider getAttitudeOverride() {
         return attitudeOverride;
     }
 
     /** Get the triggering event.
      * @return triggering event
      */
     public EventDetector getTrigger() {
         return trigger;
     }
 
     /** Get the velocity increment in satellite frame.
     * @return velocity increment in satellite frame
     */
     public Vector3D getDeltaVSat() {
         return deltaVSat;
     }
 
     /** Get the specific impulse.
     * @return specific impulse
     */
     public double getIsp() {
         return isp;
     }
 
     /** Get the control vector's cost type.
      * @return control cost type
      * @since 12.0
      */
     public Control3DVectorCostType getControl3DVectorCostType() {
         return control3DVectorCostType;
     }
 
     /** Local handler. */
     private static class Handler implements EventHandler {
 
         /** {@inheritDoc} */
         public Action eventOccurred(final SpacecraftState s, final EventDetector detector,
                                     final boolean increasing) {
 
             // filter underlying event
             final ImpulseManeuver im = (ImpulseManeuver) detector;
             final Action underlyingAction = im.trigger.getHandler().eventOccurred(s, im.trigger, increasing);
 
             return (underlyingAction == Action.STOP) ? Action.RESET_STATE : Action.CONTINUE;
 
         }
 
         /** {@inheritDoc} */
         @Override
         public SpacecraftState resetState(final EventDetector detector, final SpacecraftState oldState) {
 
             final ImpulseManeuver im = (ImpulseManeuver) detector;
             final AbsoluteDate date = oldState.getDate();
             final AttitudeProvider override = im.getAttitudeOverride();
             final Rotation rotation;
 
             if (override == null) {
                 rotation = oldState.getAttitude().getRotation();
             } else {
                 rotation = override.getAttitudeRotation(oldState.getOrbit(), date, oldState.getFrame());
             }
 
             // convert velocity increment in inertial frame
             final Vector3D deltaV = rotation.applyInverseTo(im.deltaVSat);
             final double sign     = im.forward ? +1 : -1;
 
             // apply increment to position/velocity
             final PVCoordinates oldPV = oldState.getPVCoordinates();
             final PVCoordinates newPV =
                             new PVCoordinates(oldPV.getPosition(),
                                               new Vector3D(1, oldPV.getVelocity(), sign, deltaV));
             final CartesianOrbit newOrbit =
                     new CartesianOrbit(newPV, oldState.getFrame(), date, oldState.getMu());
 
             // compute new mass
             final double normDeltaV = im.control3DVectorCostType.evaluate(im.deltaVSat);
             final double newMass = oldState.getMass() * FastMath.exp(-sign * normDeltaV / im.vExhaust);
 
             // pack everything in a new state
             SpacecraftState newState = new SpacecraftState(oldState.getOrbit().getType().normalize(newOrbit, oldState.getOrbit()),
                                                            oldState.getAttitude(), newMass);
             for (final DoubleArrayDictionary.Entry entry : oldState.getAdditionalStatesValues().getData()) {
                 newState = newState.addAdditionalState(entry.getKey(), entry.getValue());
             }
             for (final DoubleArrayDictionary.Entry entry : oldState.getAdditionalStatesDerivatives().getData()) {
                 newState = newState.addAdditionalStateDerivative(entry.getKey(), entry.getValue());
             }
             return newState;
 
         }
 
     }
 
 }