/* 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.io.BufferedReader;
  import java.io.IOException;
  import java.io.Reader;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.EnumMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.SortedSet;
  import java.util.TreeSet;
  import java.util.regex.Pattern;
  import java.util.stream.Stream;
  
  import org.hipparchus.exception.LocalizedCoreFormats;
  import org.hipparchus.geometry.euclidean.threed.Vector3D;
  import org.orekit.data.DataSource;
  import org.orekit.errors.OrekitException;
  import org.orekit.errors.OrekitMessages;
  import org.orekit.files.general.EphemerisFileParser;
  import org.orekit.files.stk.STKEphemerisFile.STKCoordinateSystem;
  import org.orekit.files.stk.STKEphemerisFile.STKEphemeris;
  import org.orekit.files.stk.STKEphemerisFile.STKEphemerisSegment;
  import org.orekit.frames.Frame;
  import org.orekit.time.AbsoluteDate;
  import org.orekit.time.DateTimeComponents;
  import org.orekit.time.Month;
  import org.orekit.time.UTCScale;
  import org.orekit.utils.CartesianDerivativesFilter;
  import org.orekit.utils.PVCoordinates;
  import org.orekit.utils.TimeStampedPVCoordinates;
  
  /**
   * Parser of {@link STKEphemerisFile}s.
   *
   * <p> The STK ephemeris file format specification is quite extensive and this implementation does not
   * attempt (nor is it possible, given the lack of an STK scenario to provide context) to support all
   * possible variations of the format. The following keywords are recognized (case-insensitive):
   * <table>
   *     <caption>Recognized Keywords</caption>
   *     <thead>
   *         <tr>
   *             <th>Keyword</th>
   *             <th>Supported</th>
   *             <th>Comment</th>
   *         </tr>
   *     </thead>
   *     <tbody>
   *         <tr>
   *             <td>stk.v.*.*</td>
   *             <td>Yes</td>
   *             <td>STK version number</td>
   *         </tr>
   *         <tr>
   *             <td>BEGIN/END Ephemeris</td>
   *             <td>Yes</td>
   *             <td></td>
   *         </tr>
   *         <tr>
   *             <td>ScenarioEpoch</td>
   *             <td>Yes</td>
   *             <td>Gregorian UTC time format (<code>dd mmm yyyy hh:mm:ss.s</code>) assumed;
   *                 the <code>TimeFormat</code> keyword is not recognized.</td>
   *         </tr>
   *         <tr>
   *             <td>CentralBody</td>
   *             <td>No</td>
   *             <td>Class constructors require gravitational parameter.</td>
   *         </tr>
   *         <tr>
   *             <td>CoordinateSystem</td>
   *             <td>Yes</td>
   *             <td>Implementation uses a frame mapping to map {@link STKCoordinateSystem}s to {@link Frame}s.</td>
   *         </tr>
   *         <tr>
   *             <td>DistanceUnit</td>
   *             <td>Yes</td>
   *             <td>Only <code>Meters</code> and <code>Kilometers</code> are supported.</td>
   *         </tr>
   *         <tr>
  *             <td>InterpolationMethod</td>
  *             <td>No</td>
  *             <td>The Orekit EphemerisSegmentPropagator class uses
  *             {@link org.orekit.utils.TimeStampedPVCoordinatesHermiteInterpolator#interpolate(AbsoluteDate, Stream)}
  *             to do Hermite interpolation, so the value of <code>InterpolationMethod</code>, if present, is
  *             ignored.</td>
  *         </tr>
  *         <tr>
  *             <td>InterpolationSamplesM1</td>
  *             <td>Yes</td>
  *             <td>Note that the <code>InterpolationMethod</code> keyword is ignored, but the value of
  *             <code>InterpolationSamplesM1</code> will be used to determine the number of sample points in the
  *             Hermite interpolator used by Orekit.</td>
  *         </tr>
  *         <tr>
  *             <td>NumberOfEphemerisPoints</td>
  *             <td>Yes</td>
  *             <td></td>
  *         </tr>
  *         <tr>
  *             <td>BEGIN/END SegmentBoundaryTimes</td>
  *             <td>Yes</td>
  *             <td></td>
  *         </tr>
  *     </tbody>
  * </table>
  *
  * <p> Any keyword in the format specification which is not explicitly named in the above table is not recognized and
  * will cause a parse exception. Those keywords that are listed above as recognized but not supported are simply
  * ignored.
  *
  * <p> The following ephemeris formats are recognized and supported:
  * <ul>
  *     <li>EphemerisTimePos</li>
  *     <li>EphemerisTimePosVel</li>
  *     <li>EphemerisTimePosVelAcc</li>
  * </ul>
  * Any ephemeris format in the format specification which is not explicitly named in the above list is not recognized
  * and will cause an exception.
  *
  * @author Andrew Goetz
  * @since 12.0
  */
 public class STKEphemerisFileParser implements EphemerisFileParser<STKEphemerisFile> {
 
     /** Pattern for delimiting regular expressions. */
     private static final Pattern SEPARATOR = Pattern.compile("\\s+");
 
     /** Pattern for ignorable lines. Comments are preceded by '#'. */
     private static final Pattern IGNORABLE_LINE = Pattern.compile("^\\s*(#.*)?");
 
     /** Regular expression that matches anything. */
     private static final String MATCH_ANY_REGEX = ".*";
 
     /** Recognized keywords. */
     private static final List<LineParser> KEYWORDS = Arrays.asList(
             LineParser.NUMBER_OF_EPHEMERIS_POINTS,
             LineParser.SCENARIO_EPOCH,
             LineParser.INTERPOLATION_METHOD,
             LineParser.INTERPOLATION_SAMPLESM1,
             LineParser.CENTRAL_BODY,
             LineParser.COORDINATE_SYSTEM,
             LineParser.BEGIN_SEGMENT_BOUNDARY_TIMES,
             LineParser.EPHEMERIS_TIME_POS,
             LineParser.EPHEMERIS_TIME_POS_VEL,
             LineParser.EPHEMERIS_TIME_POS_VEL_ACC
     );
 
     /** Satellite id. */
     private final String satelliteId;
 
     /** Gravitational parameter (m^3/s^2). */
     private final double mu;
 
     /** UTC time scale. */
     private final UTCScale utc;
 
     /** Mapping of STK coordinate system to Orekit reference frame. */
     private final Map<STKCoordinateSystem, Frame> frameMapping;
 
     /**
      * Constructs a {@link STKEphemerisFileParser} instance.
      * @param satelliteId satellite id for satellites parsed by the parser
      * @param mu gravitational parameter (m^3/s^2)
      * @param utc UTC scale for parsed dates
      * @param frameMapping mapping from STK coordinate system to Orekit frame
      */
     public STKEphemerisFileParser(final String satelliteId, final double mu, final UTCScale utc,
             final Map<STKCoordinateSystem, Frame> frameMapping) {
         this.satelliteId = Objects.requireNonNull(satelliteId);
         this.mu = mu;
         this.utc = Objects.requireNonNull(utc);
         this.frameMapping = Collections.unmodifiableMap(new EnumMap<>(frameMapping));
     }
 
     @Override
     public STKEphemerisFile parse(final DataSource source) {
 
         try (Reader reader = source.getOpener().openReaderOnce();
              BufferedReader br = (reader == null) ? null : new BufferedReader(reader)) {
 
             if (br == null) {
                 throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, source.getName());
             }
 
             // initialize internal data structures
             final ParseInfo pi = new ParseInfo();
 
             int lineNumber = 0;
             Iterable<LineParser> parsers = Collections.singleton(LineParser.VERSION);
             nextLine:
                 for (String line = br.readLine(); line != null; line = br.readLine()) {
                 ++lineNumber;
                 if (pi.file != null) {
                     break;
                 } else if (IGNORABLE_LINE.matcher(line).matches()) {
                     continue;
                 }
                 for (final LineParser candidate : parsers) {
                     if (candidate.canHandle(line)) {
                         try {
                             candidate.parse(line, pi);
                             parsers = candidate.allowedNext();
                             continue nextLine;
                         } catch (StringIndexOutOfBoundsException | IllegalArgumentException e) {
                             throw new OrekitException(e, OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE, lineNumber,
                                                       source.getName(), line);
                         }
                     }
                 }
 
                 // no parsers found for this line
                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE, lineNumber, source.getName(),
                                           line);
 
                 }
 
             if (pi.file != null) {
                 return pi.file;
             } else {
                 throw new OrekitException(OrekitMessages.STK_UNEXPECTED_END_OF_FILE, lineNumber);
             }
 
         } catch (IOException ioe) {
             throw new OrekitException(ioe, LocalizedCoreFormats.SIMPLE_MESSAGE, ioe.getLocalizedMessage());
         }
     }
 
     /**
      * Transient data used for parsing an STK ephemeris file. The data is kept in a
      * separate data structure to make the parser thread-safe.
      * <p>
      * <b>Note</b>: The class intentionally does not provide accessor methods, as it
      * is only used internally for parsing an STK ephemeris file.
      * </p>
      */
     private final class ParseInfo {
 
         /** STK version. */
         private String stkVersion;
 
         /** Scenario epoch. */
         private AbsoluteDate scenarioEpoch; // technically optional but required here b/c no STK scenario for context
 
         /** Number of ephemeris points. */
         private Integer numberOfEphemerisPoints;
 
         /** One less than the number of points used in the interpolation. */
         private int interpolationSamplesM1;
 
         /** Cartesian derivatives filter for interpolation. */
         private CartesianDerivativesFilter cartesianDerivativesFilter;
 
         /** Coordinate system. */
         private STKCoordinateSystem coordinateSystem;
 
         /** Distance unit. */
         private STKDistanceUnit distanceUnit;
 
         /** Number of ephemeris points read. */
         private int numberOfEphemerisPointsRead;
 
         /** Segment boundary times. */
         private SortedSet<Double> segmentBoundaryTimes;
 
         /** Ephemeris segments. */
         private List<STKEphemerisSegment> ephemerisSegments;
 
         /** Last-saved ephemeris. */
         private TimeStampedPVCoordinates lastSavedEphemeris;
 
         /** Ephemeris for current segment. */
         private List<TimeStampedPVCoordinates> segmentEphemeris;
 
         /** Completely parsed ephemeris file. */
         private STKEphemerisFile file;
 
         /**
          * Constructs a {@link ParseInfo} instance.
          */
         private ParseInfo() {
             // Set defaults.
             this.distanceUnit = STKDistanceUnit.METERS;
             this.interpolationSamplesM1 = 5;
             this.coordinateSystem = STKCoordinateSystem.FIXED;
 
             // Other initialization.
             this.ephemerisSegments = new ArrayList<>();
             this.segmentBoundaryTimes = new TreeSet<>();
             this.segmentEphemeris = new ArrayList<>();
         }
 
         /**
          * Returns the UTC scale.
          * @return UTC scale
          */
         private UTCScale getUTCScale() {
             return utc;
         }
 
         /**
          * Adds an ephemeris point.
          * @param time time
          * @param pvCoordinates position/velocity coordinates
          */
         private void addEphemeris(final double time, final PVCoordinates pvCoordinates) {
             if (numberOfEphemerisPoints != null && numberOfEphemerisPointsRead == numberOfEphemerisPoints) {
                 return;
             }
             final AbsoluteDate date = scenarioEpoch.shiftedBy(time);
             final TimeStampedPVCoordinates timeStampedPVCoordinates = new TimeStampedPVCoordinates(date, pvCoordinates);
             if (segmentBoundaryTimes.contains(time) && numberOfEphemerisPointsRead > 0) {
                 if (segmentEphemeris.isEmpty()) { // begin new segment
                     if (!date.equals(lastSavedEphemeris.getDate())) {
                         segmentEphemeris.add(lastSavedEphemeris); // no gaps allowed
                     }
                     segmentEphemeris.add(timeStampedPVCoordinates);
                 } else { // end segment
                     segmentEphemeris.add(timeStampedPVCoordinates);
                     ephemerisSegments.add(new STKEphemerisSegment(mu, getFrame(), 1 + interpolationSamplesM1,
                             cartesianDerivativesFilter, segmentEphemeris));
                     segmentEphemeris = new ArrayList<>();
                 }
             } else {
                 segmentEphemeris.add(timeStampedPVCoordinates);
             }
             lastSavedEphemeris = timeStampedPVCoordinates;
             ++numberOfEphemerisPointsRead;
         }
 
         /**
          * Returns the frame.
          * @return frame
          */
         private Frame getFrame() {
             final STKCoordinateSystem stkCoordinateSystem = coordinateSystem == null ? STKCoordinateSystem.FIXED :
                     coordinateSystem;
             final Frame frame = frameMapping.get(stkCoordinateSystem);
             if (frame == null) {
                 throw new OrekitException(OrekitMessages.STK_UNMAPPED_COORDINATE_SYSTEM, stkCoordinateSystem);
             }
             return frame;
         }
 
         /**
          * Completes parsing.
          */
         private void complete() {
             if (!segmentEphemeris.isEmpty()) {
                 ephemerisSegments.add(new STKEphemerisSegment(mu, getFrame(), 1 + interpolationSamplesM1,
                         cartesianDerivativesFilter, segmentEphemeris));
             }
             final STKEphemeris ephemeris = new STKEphemeris(satelliteId, mu, ephemerisSegments);
             file = new STKEphemerisFile(stkVersion, satelliteId, ephemeris);
         }
 
     }
 
     /** Parser for specific line. */
     private enum LineParser {
 
         /** STK version. */
         VERSION("^stk\\.v\\.\\d+\\.\\d+$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 pi.stkVersion = line;
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return Collections.singleton(BEGIN_EPHEMERIS);
             }
 
         },
 
         /** BEGIN Ephemeris keyword. */
         BEGIN_EPHEMERIS("^\\s*BEGIN Ephemeris\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 // nothing to do
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return KEYWORDS;
             }
 
         },
 
         /** NumberOfEphemerisPoints keyword. */
         NUMBER_OF_EPHEMERIS_POINTS("^\\s*NumberOfEphemerisPoints\\s*\\d+\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 pi.numberOfEphemerisPoints = Integer.parseInt(SEPARATOR.split(line.trim())[1]);
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return KEYWORDS;
             }
 
         },
 
         /** ScenarioEpoch keyword. */
         SCENARIO_EPOCH("^\\s*ScenarioEpoch\\s* \\d{2} [a-zA-Z]{3} \\d{4} \\d{2}:\\d{2}:\\d{2}(\\.\\d*)?\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 final String[] tokens = SEPARATOR.split(line.trim());
                 final int dayOfMonth = Integer.parseInt(tokens[1]);
                 final Month month = Month.parseMonth(tokens[2]);
                 final int year = Integer.parseInt(tokens[3]);
                 final int hour = Integer.parseInt(tokens[4].substring(0, 2));
                 final int minute = Integer.parseInt(tokens[4].substring(3, 5));
                 final double seconds = Double.parseDouble(tokens[4].substring(6));
                 final DateTimeComponents dateTimeComponents = new DateTimeComponents(year, month, dayOfMonth, hour, minute, seconds);
                 pi.scenarioEpoch = new AbsoluteDate(dateTimeComponents, pi.getUTCScale());
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return KEYWORDS;
             }
 
         },
 
         /** InterpolationMethod keyword. */
         INTERPOLATION_METHOD("^\\s*InterpolationMethod\\s+[a-zA-Z]+\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 // do nothing; this keyword is recognized, but ignored and unsupported
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return KEYWORDS;
             }
 
         },
 
         /** InterpolationSamplesM1 keyword. */
         INTERPOLATION_SAMPLESM1("^\\s*InterpolationSamplesM1\\s+\\d+\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 pi.interpolationSamplesM1 = Integer.parseInt(SEPARATOR.split(line.trim())[1]);
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return KEYWORDS;
             }
 
         },
 
         /** CentralBody keyword. */
         CENTRAL_BODY("^\\s*CentralBody\\s+[a-zA-Z]+\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 // do nothing; this keyword is recognized, but ignored and unsupported; Earth
                 // assumed
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return KEYWORDS;
             }
 
         },
 
         /** CoordinateSystem keyword. */
         COORDINATE_SYSTEM("^\\s*CoordinateSystem\\s+[a-zA-Z0-9]+\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 pi.coordinateSystem = STKCoordinateSystem.parse(SEPARATOR.split(line.trim())[1]);
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return KEYWORDS;
             }
 
         },
 
         /** DistanceUnit keyword. */
         DISTANCE_UNIT("^\\s*DistanceUnit\\s+[a-zA-Z0-9]+\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 pi.distanceUnit = STKDistanceUnit.valueOf(SEPARATOR.split(line.trim())[1].toUpperCase());
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return KEYWORDS;
             }
 
         },
 
         /** BEGIN SegmentBoundaryTimes keyword. */
         BEGIN_SEGMENT_BOUNDARY_TIMES("^\\s*BEGIN SegmentBoundaryTimes\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 // nothing to be done
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return Collections.singleton(SEGMENT_BOUNDARY_TIME);
             }
 
         },
 
         /** Segment boundary time. */
         SEGMENT_BOUNDARY_TIME(MATCH_ANY_REGEX) {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 pi.segmentBoundaryTimes.add(Double.parseDouble(SEPARATOR.split(line.trim())[0]));
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return Arrays.asList(END_SEGMENT_BOUNDARY_TIMES, SEGMENT_BOUNDARY_TIME);
             }
 
         },
 
         /** END SegmentBoundaryTimes keyword. */
         END_SEGMENT_BOUNDARY_TIMES("^\\s*END SegmentBoundaryTimes\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 // nothing to be done
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return KEYWORDS;
             }
 
         },
 
         /** EphemerisTimePos keyword. */
         EPHEMERIS_TIME_POS("^\\s*EphemerisTimePos\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 pi.cartesianDerivativesFilter = CartesianDerivativesFilter.USE_P;
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return Collections.singleton(EPHEMERIS_TIME_POS_DATUM);
             }
 
         },
 
         /** EphemerisTimePos datum. */
         EPHEMERIS_TIME_POS_DATUM(MATCH_ANY_REGEX) {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 final String[] tokens = SEPARATOR.split(line.trim());
                 final double time = Double.parseDouble(tokens[0]);
                 final double px = Double.parseDouble(tokens[1]) * pi.distanceUnit.conversionToMetersFactor;
                 final double py = Double.parseDouble(tokens[2]) * pi.distanceUnit.conversionToMetersFactor;
                 final double pz = Double.parseDouble(tokens[3]) * pi.distanceUnit.conversionToMetersFactor;
 
                 final Vector3D position = new Vector3D(px, py, pz);
                 final Vector3D velocity = Vector3D.ZERO;
 
                 pi.addEphemeris(time, new PVCoordinates(position, velocity));
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return Arrays.asList(END_EPHEMERIS, EPHEMERIS_TIME_POS_DATUM);
             }
 
         },
 
         /** EphemerisTimePosVel keyword. */
         EPHEMERIS_TIME_POS_VEL("^\\s*EphemerisTimePosVel\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 pi.cartesianDerivativesFilter = CartesianDerivativesFilter.USE_PV;
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return Collections.singleton(EPHEMERIS_TIME_POS_VEL_DATUM);
             }
 
         },
 
         /** EphemerisTimePosVel datum. */
         EPHEMERIS_TIME_POS_VEL_DATUM(MATCH_ANY_REGEX) {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 final String[] tokens = SEPARATOR.split(line.trim());
                 final double time = Double.parseDouble(tokens[0]);
                 final double px = Double.parseDouble(tokens[1]) * pi.distanceUnit.conversionToMetersFactor;
                 final double py = Double.parseDouble(tokens[2]) * pi.distanceUnit.conversionToMetersFactor;
                 final double pz = Double.parseDouble(tokens[3]) * pi.distanceUnit.conversionToMetersFactor;
                 final double vx = Double.parseDouble(tokens[4]) * pi.distanceUnit.conversionToMetersFactor;
                 final double vy = Double.parseDouble(tokens[5]) * pi.distanceUnit.conversionToMetersFactor;
                 final double vz = Double.parseDouble(tokens[6]) * pi.distanceUnit.conversionToMetersFactor;
 
                 final Vector3D position = new Vector3D(px, py, pz);
                 final Vector3D velocity = new Vector3D(vx, vy, vz);
 
                 pi.addEphemeris(time, new PVCoordinates(position, velocity));
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return Arrays.asList(END_EPHEMERIS, EPHEMERIS_TIME_POS_VEL_DATUM);
             }
 
         },
 
         /** EphemerisTimePosVelAcc keyword. */
         EPHEMERIS_TIME_POS_VEL_ACC("^\\s*EphemerisTimePosVelAcc\\s*(#.*)?$") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 pi.cartesianDerivativesFilter = CartesianDerivativesFilter.USE_PVA;
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return Collections.singleton(EPHEMERIS_TIME_POS_VEL_ACC_DATUM);
             }
 
         },
 
         /** EphemerisTimePosVelAcc datum. */
         EPHEMERIS_TIME_POS_VEL_ACC_DATUM(MATCH_ANY_REGEX) {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 final String[] tokens = SEPARATOR.split(line.trim());
                 final double time = Double.parseDouble(tokens[0]);
                 final double px = Double.parseDouble(tokens[1]) * pi.distanceUnit.conversionToMetersFactor;
                 final double py = Double.parseDouble(tokens[2]) * pi.distanceUnit.conversionToMetersFactor;
                 final double pz = Double.parseDouble(tokens[3]) * pi.distanceUnit.conversionToMetersFactor;
                 final double vx = Double.parseDouble(tokens[4]) * pi.distanceUnit.conversionToMetersFactor;
                 final double vy = Double.parseDouble(tokens[5]) * pi.distanceUnit.conversionToMetersFactor;
                 final double vz = Double.parseDouble(tokens[6]) * pi.distanceUnit.conversionToMetersFactor;
                 final double ax = Double.parseDouble(tokens[7]) * pi.distanceUnit.conversionToMetersFactor;
                 final double ay = Double.parseDouble(tokens[8]) * pi.distanceUnit.conversionToMetersFactor;
                 final double az = Double.parseDouble(tokens[9]) * pi.distanceUnit.conversionToMetersFactor;
 
                 final Vector3D position = new Vector3D(px, py, pz);
                 final Vector3D velocity = new Vector3D(vx, vy, vz);
                 final Vector3D acceleration = new Vector3D(ax, ay, az);
 
                 pi.addEphemeris(time, new PVCoordinates(position, velocity, acceleration));
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return Arrays.asList(END_EPHEMERIS, EPHEMERIS_TIME_POS_VEL_ACC_DATUM);
             }
 
         },
 
         /** END Ephemeris keyword. */
         END_EPHEMERIS("\\s*END Ephemeris\\s*(#.*)?") {
 
             @Override
             public void parse(final String line, final ParseInfo pi) {
                 pi.complete();
             }
 
             @Override
             public Iterable<LineParser> allowedNext() {
                 return Collections.emptyList();
             }
 
         };
 
         /** Pattern for identifying line. */
         private final Pattern pattern;
 
         /**
          * Constructs a {@link LineParser} instance.
          * @param regex regular expression for identifying line
          */
         LineParser(final String regex) {
             pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
         }
 
         /**
          * Parses a line.
          * @param line line to parse
          * @param pi holder for transient data
          */
         public abstract void parse(String line, ParseInfo pi);
 
         /**
          * Returns the allowed parsers for the next line.
          * @return returns the allowed parsers for the next line
          */
         public abstract Iterable<LineParser> allowedNext();
 
         /**
          * Checks if a parser can handle line.
          * @param line line to parse
          * @return true if parser can handle the specified line
          */
         public boolean canHandle(final String line) {
             return pattern.matcher(line).matches();
         }
 
     }
 
     /** STK distance unit. */
     private enum STKDistanceUnit {
 
         /** Kilometers. */
         KILOMETERS(1000.0),
 
         /** Meters. */
         METERS(1.0);
 
         /** Factor by which to multiply to convert the distance unit to meters. */
         private final double conversionToMetersFactor;
 
         /**
          * Constructs a {@link STKDistanceUnit} instance.
          * @param conversionToMetersFactor factor by which to multiply to
          *        convert the distance unit to meters
          */
         STKDistanceUnit(final double conversionToMetersFactor) {
             this.conversionToMetersFactor = conversionToMetersFactor;
         }
 
     }
 
 }