/* Copyright 2002-2023 Andrew Goetz
    * 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.stk;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Objects;
  
  import org.orekit.errors.OrekitException;
  import org.orekit.errors.OrekitMessages;
  import org.orekit.files.general.EphemerisFile;
  import org.orekit.files.stk.STKEphemerisFile.STKEphemerisSegment;
  import org.orekit.frames.Frame;
  import org.orekit.time.AbsoluteDate;
  import org.orekit.utils.CartesianDerivativesFilter;
  import org.orekit.utils.TimeStampedPVCoordinates;
  
  /**
   * STK ephemeris file.
   *
   * @author Andrew Goetz
   * @since 12.0
   */
  public class STKEphemerisFile implements EphemerisFile<TimeStampedPVCoordinates, STKEphemerisSegment> {
  
      /** STK version. */
      private final String stkVersion;
  
      /** Unmodifiable mapping with a single key-value pair from satellite id to ephemeris. */
      private final Map<String, STKEphemeris> satellites;
  
      /**
       * Constructs a {@link STKEphemerisFile} instance.
       * @param stkVersion STK version string (example: "stk.v.11.0")
       * @param satelliteId satellite id
       * @param ephemeris ephemeris
       */
      public STKEphemerisFile(final String stkVersion, final String satelliteId, final STKEphemeris ephemeris) {
          this.stkVersion = Objects.requireNonNull(stkVersion);
          final Map<String, STKEphemeris> tempMap = new HashMap<>();
          tempMap.put(satelliteId, ephemeris);
          this.satellites = Collections.unmodifiableMap(tempMap);
      }
  
      /**
       * Returns the STK version string.
       * @return STK version string
       */
      public String getSTKVersion() {
          return stkVersion;
      }
  
      /**
       * {@inheritDoc}
       * <p>
       * STK ephemeris files define ephemeris for a single satellite, so the returned
       * map will have a single entry.
       * </p>
       */
      @Override
      public Map<String, STKEphemeris> getSatellites() {
          return satellites;
      }
  
      /**
       * Ephemeris segment from an STK ephemeris file.
       */
      public static class STKEphemerisSegment implements EphemerisFile.EphemerisSegment<TimeStampedPVCoordinates> {
  
          /** Gravitational parameter (m^3/s^2). */
          private final double mu;
  
          /** Reference frame. */
          private final Frame frame;
  
          /** Number of samples to use in interpolation. */
          private final int interpolationSamples;
  
          /** Cartesian derivatives filter. */
          private final CartesianDerivativesFilter cartesianDerivativesFilter;
  
         /** Time-sorted time/position/velocity data. */
         private final List<TimeStampedPVCoordinates> timeStampedPVCoordinates;
 
         /**
          * Constructs a {@link STKEphemerisSegment} instance.
          * @param mu gravitational parameter (m^3/s^2)
          * @param frame frame
          * @param interpolationSamples number of samples to use in interpolation
          * @param cartesianDerivativesFilter Cartesian derivatives filter
          * @param timeStampedPVCoordinates time-sorted time/position/velocity data
          */
         public STKEphemerisSegment(final double mu, final Frame frame, final int interpolationSamples,
                 final CartesianDerivativesFilter cartesianDerivativesFilter,
                 final List<TimeStampedPVCoordinates> timeStampedPVCoordinates) {
             this.mu = mu;
             this.frame = Objects.requireNonNull(frame);
             this.interpolationSamples = interpolationSamples;
             this.cartesianDerivativesFilter = Objects.requireNonNull(cartesianDerivativesFilter);
             this.timeStampedPVCoordinates = Collections.unmodifiableList(new ArrayList<>(timeStampedPVCoordinates));
         }
 
         @Override
         public double getMu() {
             return mu;
         }
 
         @Override
         public Frame getFrame() {
             return frame;
         }
 
         @Override
         public int getInterpolationSamples() {
             return interpolationSamples;
         }
 
         @Override
         public CartesianDerivativesFilter getAvailableDerivatives() {
             return cartesianDerivativesFilter;
         }
 
         @Override
         public List<TimeStampedPVCoordinates> getCoordinates() {
             return timeStampedPVCoordinates;
         }
 
         @Override
         public AbsoluteDate getStart() {
             return timeStampedPVCoordinates.get(0).getDate();
         }
 
         @Override
         public AbsoluteDate getStop() {
             return timeStampedPVCoordinates.get(timeStampedPVCoordinates.size() - 1).getDate();
         }
 
     }
 
     /**
      * Ephemeris from an STK ephemeris file.
      */
     public static class STKEphemeris implements SatelliteEphemeris<TimeStampedPVCoordinates, STKEphemerisSegment> {
 
         /** Satellite id.*/
         private final String satelliteId;
 
         /** Gravitational parameter (m^3/s^2). */
         private final double mu;
 
         /** Unmodifiable list of ephemeris segments. */
         private final List<STKEphemerisSegment> segments;
 
         /**
          * Constructs a {@link STKEphemeris} instance. This constructor shallowly copies the list of segments provided.
          * @param satelliteId satellite id
          * @param mu gravitational parameter (m^3/s^2)
          * @param segments ephemeris segments
          */
         public STKEphemeris(final String satelliteId, final double mu, final List<STKEphemerisSegment> segments) {
             this.satelliteId = Objects.requireNonNull(satelliteId);
             this.mu = mu;
             this.segments = Collections.unmodifiableList(new ArrayList<>(segments));
         }
 
         @Override
         public String getId() {
             return satelliteId;
         }
 
         @Override
         public double getMu() {
             return mu;
         }
 
         @Override
         public List<STKEphemerisSegment> getSegments() {
             return segments;
         }
 
         @Override
         public AbsoluteDate getStart() {
             return segments.get(0).getStart();
         }
 
         @Override
         public AbsoluteDate getStop() {
             return segments.get(segments.size() - 1).getStop();
         }
 
     }
 
     /**
      * STK coordinate system.
      * <p>
      * Currently, only Earth-centered coordinate systems are supported.
      * </p>
      */
     public enum STKCoordinateSystem {
 
         /** International Celestial Reference Frame. */
         ICRF,
 
         /** Mean equator and mean equinox of the J2000 epoch. */
         J2000,
 
         /** Central-body-dependent inertial frame, equivalent to ICRF for Earth. */
         INERTIAL,
 
         /** Fixed frame. */
         FIXED,
 
         /** True equator and true equinox of date. */
         TRUE_OF_DATE,
 
         /** Mean equator and mean equinox of date. */
         MEAN_OF_DATE,
 
         /** True equator and mean equinox of date. */
         TEME_OF_DATE;
 
         /**
          * Parses a coordinate system from a string.
          * @param s string
          * @return coordinate system
          */
         public static STKCoordinateSystem parse(final String s) {
             final String sUpper = s.toUpperCase(Locale.US);
             switch (sUpper) {
                 case "ICRF":
                     return ICRF;
                 case "J2000":
                     return J2000;
                 case "INERTIAL":
                     return INERTIAL;
                 case "FIXED":
                     return FIXED;
                 case "TRUEOFDATE":
                     return TRUE_OF_DATE;
                 case "MEANOFDATE":
                     return MEAN_OF_DATE;
                 case "TEMEOFDATE":
                     return TEME_OF_DATE;
                 default:
                     throw new OrekitException(OrekitMessages.STK_INVALID_OR_UNSUPPORTED_COORDINATE_SYSTEM, s);
             }
         }
 
     }
 
 }