/* Copyright 2013-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.rugged.refraction;
  
  import org.hipparchus.analysis.interpolation.BilinearInterpolatingFunction;
  import org.hipparchus.geometry.euclidean.threed.Vector3D;
  import org.orekit.rugged.errors.RuggedException;
  import org.orekit.rugged.errors.RuggedMessages;
  import org.orekit.rugged.intersection.IntersectionAlgorithm;
  import org.orekit.rugged.linesensor.LineSensor;
  import org.orekit.rugged.linesensor.SensorPixel;
  import org.orekit.rugged.utils.NormalizedGeodeticPoint;
  
  /**
   * Base class for atmospheric refraction model.
   * @author Sergio Esteves
   * @author Guylaine Prat
   * @since 2.0
   */
  public abstract class AtmosphericRefraction {
  
      /** Flag to tell if we must compute the correction.
       * By default: computation is set up.
       * @since 2.1
       */
      private boolean mustBeComputed;
  
      /** The current atmospheric parameters.
       * @since 2.1
       */
      private AtmosphericComputationParameters atmosphericParams;
  
      /** Bilinear interpolating function for pixel (used by inverse location).
       * @since 2.1
      */
      private BilinearInterpolatingFunction bifPixel;
  
      /** Bilinear interpolating function of line (used by inverse location).
       * @since 2.1
      */
      private BilinearInterpolatingFunction bifLine;
  
      /**
       * Default constructor.
       */
      protected AtmosphericRefraction() {
          // Set up the atmospheric parameters ... with lazy evaluation of the grid (done only if necessary)
          this.atmosphericParams = new AtmosphericComputationParameters();
          this.mustBeComputed    = true;
          this.bifPixel          = null;
          this.bifLine           = null;
      }
  
      /** Apply correction to the intersected point with an atmospheric refraction model.
       * @param satPos satellite position, in <em>body frame</em>
       * @param satLos satellite line of sight, in <em>body frame</em>
       * @param rawIntersection intersection point before refraction correction
       * @param algorithm intersection algorithm
       * @return corrected point with the effect of atmospheric refraction
       * {@link org.orekit.rugged.utils.ExtendedEllipsoid#pointAtAltitude(Vector3D, Vector3D, double)} or see
       * {@link org.orekit.rugged.intersection.IntersectionAlgorithm#refineIntersection(org.orekit.rugged.utils.ExtendedEllipsoid, Vector3D, Vector3D, NormalizedGeodeticPoint)}
       */
      public abstract NormalizedGeodeticPoint applyCorrection(Vector3D satPos, Vector3D satLos, NormalizedGeodeticPoint rawIntersection,
                                              IntersectionAlgorithm algorithm);
  
      /** Deactivate computation (needed for the inverse location computation).
       * @since 2.1
       */
      public void deactivateComputation() {
          this.mustBeComputed = false;
      }
  
      /** Reactivate computation (needed for the inverse location computation).
       * @since 2.1
       */
      public void reactivateComputation() {
          this.mustBeComputed = true;
      }
  
      /** Tell if the computation must be performed.
       * @return true if computation must be performed; false otherwise
       * @since 2.1
       */
      public boolean mustBeComputed() {
          return mustBeComputed;
     }
 
     /** Configuration of the interpolation grid. This grid is associated to the given sensor,
      * with the given min and max lines.
      * @param sensor line sensor
      * @param minLine min line defined for the inverse location
      * @param maxLine max line defined for the inverse location
      * @since 2.1
      */
     public void configureCorrectionGrid(final LineSensor sensor, final int minLine, final int maxLine) {
 
         atmosphericParams.configureCorrectionGrid(sensor, minLine, maxLine);
     }
 
    /** Check if the current atmospheric parameters are the same as the asked ones.
     * @param sensorName the asked sensor name
     * @param minLine the asked min line
     * @param maxLine the asked max line
     * @return true if same context; false otherwise
     * @since 2.1
     */
     public Boolean isSameContext(final String sensorName, final int minLine, final int maxLine) {
 
         return Double.compare(atmosphericParams.getMinLineSensor(), minLine) == 0 &&
                Double.compare(atmosphericParams.getMaxLineSensor(), maxLine) == 0 &&
                atmosphericParams.getSensorName().compareTo(sensorName) == 0;
     }
 
     /** Get the computation parameters.
      * @return the AtmosphericComputationParameters
      * @since 2.1
      */
     public AtmosphericComputationParameters getComputationParameters() {
         return atmosphericParams;
     }
 
     /** Set the grid steps in pixel and line (used to compute inverse location).
      * Overwrite the default values, for time optimization for instance.
      * @param pixelStep pixel step for the inverse location computation
      * @param lineStep line step for the inverse location computation
      * @since 2.1
      */
     public void setGridSteps(final int pixelStep, final int lineStep) {
         atmosphericParams.setGridSteps(pixelStep, lineStep);
     }
 
     /**
      * Set the margin for computation of inverse location with atmospheric refraction correction.
      * Overwrite the default value DEFAULT_INVLOC_MARGIN.
      * No check is done about this margin. A recommended value is around 1.
      * @param inverseLocMargin margin in pixel size to compute inverse location with atmospheric refraction correction.
      * @since 3.0
      */
     public void setInverseLocMargin(final double inverseLocMargin) {
         atmosphericParams.setInverseLocMargin(inverseLocMargin);
     }
 
     /** Compute the correction functions for pixel and lines.
      * The corrections are computed for pixels and lines, on a regular grid at sensor level.
      * The corrections are based on the difference on grid nodes (where direct loc is known with atmosphere refraction)
      * and the sensor pixel found by inverse loc without atmosphere refraction.
      * The bilinear interpolating functions are then computed for pixel and for line.
      * Need to be computed only once for a given sensor with the same minLine and maxLine.
      * @param sensorPixelGridInverseWithout inverse location grid WITHOUT atmospheric refraction
      * @since 2.1
      */
     public void computeGridCorrectionFunctions(final SensorPixel[][] sensorPixelGridInverseWithout) {
 
         final int nbPixelGrid = atmosphericParams.getNbPixelGrid();
         final int nbLineGrid = atmosphericParams.getNbLineGrid();
         final double[] pixelGrid = atmosphericParams.getUgrid();
         final double[] lineGrid = atmosphericParams.getVgrid();
 
         // Initialize the needed diff functions
         final double[][] gridDiffPixel = new double[nbPixelGrid][nbLineGrid];
         final double[][] gridDiffLine = new double[nbPixelGrid][nbLineGrid];
 
         // Compute the difference between grids nodes WITH - without atmosphere
         for (int lineIndex = 0; lineIndex < nbLineGrid; lineIndex++) {
             for (int pixelIndex = 0; pixelIndex < nbPixelGrid; pixelIndex++) {
 
                 if (sensorPixelGridInverseWithout[pixelIndex][lineIndex] != null) {
                     final double diffLine = lineGrid[lineIndex] - sensorPixelGridInverseWithout[pixelIndex][lineIndex].getLineNumber();
                     final double diffPixel = pixelGrid[pixelIndex] - sensorPixelGridInverseWithout[pixelIndex][lineIndex].getPixelNumber();
                     gridDiffPixel[pixelIndex][lineIndex] = diffPixel;
                     gridDiffLine[pixelIndex][lineIndex] = diffLine;
 
                 } else {
                     // Impossible to find the sensor pixel in the given range lines
                     throw new RuggedException(RuggedMessages.SENSOR_PIXEL_NOT_FOUND_IN_RANGE_LINES,
                                               atmosphericParams.getMinLineSensor(), atmosphericParams.getMaxLineSensor());
                 }
             }
         }
         // Definition of the interpolating function for pixel and for line
         this.bifPixel = new BilinearInterpolatingFunction(pixelGrid, lineGrid, gridDiffPixel);
         this.bifLine = new BilinearInterpolatingFunction(pixelGrid, lineGrid, gridDiffLine);
     }
 
     /**
      * @return the bilinear interpolating function for pixel correction
      */
     public BilinearInterpolatingFunction getBifPixel() {
         return bifPixel;
     }
 
     /**
      * @return the bilinear interpolating function for line correction
      */
     public BilinearInterpolatingFunction getBifLine() {
         return bifLine;
     }
 }