/* Copyright 2022-2025 Romain Serra
    * 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.radiation;
  
  import org.hipparchus.CalculusFieldElement;
  import org.hipparchus.Field;
  import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  import org.hipparchus.geometry.euclidean.threed.Vector3D;
  import org.orekit.propagation.events.CylindricalShadowEclipseDetector;
  import org.orekit.propagation.events.EventDetector;
  import org.orekit.propagation.events.EventDetectionSettings;
  import org.orekit.propagation.events.FieldCylindricalShadowEclipseDetector;
  import org.orekit.propagation.events.FieldEventDetector;
  import org.orekit.propagation.events.FieldEventDetectionSettings;
  import org.orekit.propagation.events.handlers.FieldResetDerivativesOnEvent;
  import org.orekit.propagation.events.handlers.ResetDerivativesOnEvent;
  import org.orekit.utils.ExtendedPositionProvider;
  
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * Class defining a flux model with a single occulting body, casting a shadow whose shape is a circular cylinder
   * (equivalent to the light source being infinitely distant). It is less accurate but faster to evaluate than a conical
   * model.
   *
   * @author Romain Serra
   * @see AbstractSolarLightFluxModel
   * @see LightFluxModel
   * @since 12.1
   */
  public class CylindricallyShadowedLightFluxModel extends AbstractSolarLightFluxModel {
  
      /**
       * Default max. check interval for eclipse detection.
       */
      private static final double CYLINDRICAL_ECLIPSE_MAX_CHECK = 100;
  
      /**
       * Default threshold for eclipse detection.
       */
      private static final double CYLINDRICAL_ECLIPSE_THRESHOLD = 1e-7;
  
      /**
       * Constructor.
       * @param kRef reference flux
       * @param occultedBody position provider for light source
       * @param occultingBodyRadius radius of central, occulting body
       * @param eventDetectionSettings user-defined detection settings for eclipses (if ill-tuned, events might be missed or performance might drop)
       * @since 12.2
       */
      public CylindricallyShadowedLightFluxModel(final double kRef, final ExtendedPositionProvider occultedBody,
                                                 final double occultingBodyRadius, final EventDetectionSettings eventDetectionSettings) {
          super(kRef, occultedBody, occultingBodyRadius, eventDetectionSettings);
      }
  
      /**
       * Constructor with default event detection settings.
       * @param kRef reference flux
       * @param occultedBody position provider for light source
       * @param occultingBodyRadius radius of central, occulting body
       */
      public CylindricallyShadowedLightFluxModel(final double kRef, final ExtendedPositionProvider occultedBody,
                                                 final double occultingBodyRadius) {
          this(kRef, occultedBody, occultingBodyRadius, getDefaultEclipseDetectionSettings());
      }
  
      /**
       * Constructor with default value for reference flux.
       * @param occultedBody position provider for light source
       * @param occultingBodyRadius radius of central, occulting body
       */
      public CylindricallyShadowedLightFluxModel(final ExtendedPositionProvider occultedBody,
                                                 final double occultingBodyRadius) {
          super(occultedBody, occultingBodyRadius, getDefaultEclipseDetectionSettings());
      }
  
      /**
       * Define default detection settings for eclipses.
       * @return default settings
       * @since 12.2
       */
      public static EventDetectionSettings getDefaultEclipseDetectionSettings() {
          return new EventDetectionSettings(CYLINDRICAL_ECLIPSE_MAX_CHECK, CYLINDRICAL_ECLIPSE_THRESHOLD,
                  EventDetectionSettings.DEFAULT_MAX_ITER);
     }
 
     /** {@inheritDoc} */
     @Override
     protected double getLightingRatio(final Vector3D position, final Vector3D occultedBodyPosition) {
         final Vector3D occultedBodyDirection = occultedBodyPosition.normalize();
         final double dotProduct = position.dotProduct(occultedBodyDirection);
         if (dotProduct < 0.) {
             final double distanceToCylinderAxis = (position.subtract(occultedBodyDirection.scalarMultiply(dotProduct))).getNorm();
             if (distanceToCylinderAxis <= getOccultingBodyRadius()) {
                 return 0.;
             }
         }
         return 1.;
     }
 
     /** {@inheritDoc} */
     @Override
     protected <T extends CalculusFieldElement<T>> T getLightingRatio(final FieldVector3D<T> position,
                                                                      final FieldVector3D<T> occultedBodyPosition) {
         final Field<T> field = position.getX().getField();
         final FieldVector3D<T> occultedBodyDirection = occultedBodyPosition.normalize();
         final T dotProduct = position.dotProduct(occultedBodyDirection);
         if (dotProduct.getReal() < 0.) {
             final T distanceToCylinderAxis = (position.subtract(occultedBodyDirection.scalarMultiply(dotProduct))).getNorm();
             if (distanceToCylinderAxis.getReal() <= getOccultingBodyRadius()) {
                 return field.getZero();
             }
         }
         return field.getOne();
     }
 
 
     /** {@inheritDoc} */
     @Override
     public List<EventDetector> getEclipseConditionsDetector() {
         final List<EventDetector> detectors = new ArrayList<>();
         detectors.add(createCylindricalShadowEclipseDetector().withDetectionSettings(getEventDetectionSettings()));
         return detectors;
     }
 
     /**
      * Method to create a new eclipse detector.
      * @return detector
      */
     private CylindricalShadowEclipseDetector createCylindricalShadowEclipseDetector() {
         return new CylindricalShadowEclipseDetector(getOccultedBody(), getOccultingBodyRadius(),
                 new ResetDerivativesOnEvent());
     }
 
     /** {@inheritDoc} */
     @Override
     public <T extends CalculusFieldElement<T>> List<FieldEventDetector<T>> getFieldEclipseConditionsDetector(final Field<T> field) {
         final List<FieldEventDetector<T>> detectors = new ArrayList<>();
         final FieldEventDetectionSettings<T> detectionSettings = new FieldEventDetectionSettings<>(field, getEventDetectionSettings());
         detectors.add(createFieldCylindricalShadowEclipseDetector(field).withDetectionSettings(detectionSettings));
         return detectors;
     }
 
     /**
      * Method to create a new eclipse detector. Field version.
      * @param field field
      * @param <T> field type
      * @return detector
      */
     private <T extends CalculusFieldElement<T>> FieldCylindricalShadowEclipseDetector<T> createFieldCylindricalShadowEclipseDetector(final Field<T> field) {
         final T occultingBodyRadiusAsField = field.getZero().newInstance(getOccultingBodyRadius());
         return new FieldCylindricalShadowEclipseDetector<>(getOccultedBody(), occultingBodyRadiusAsField,
                 new FieldResetDerivativesOnEvent<>());
     }
 }