VectorEpochTerm.java

/* Copyright 2024-2025 The Johns Hopkins University Applied Physics Laboratory
 * 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.iirv.terms;

import org.orekit.files.iirv.terms.base.DoubleValuedIIRVTerm;
import org.orekit.files.iirv.terms.base.IIRVVectorTerm;
import org.orekit.time.AbsoluteDate;
import org.orekit.time.TimeComponents;
import org.orekit.time.UTCScale;

import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Locale;

/**
 * Vector epoch in UTC with resolution to nearest millisecond.
 * <p>
 * Valid values:
 * <p>
 * hhmmsssss where:
 * <ul>
 * <li> hh = 00 to 23
 * <li> mm = 00 to 59
 * <li> sssss = 00000 to 59999 (milliseconds, implied decimal point three places from right)
 * </ul>
 *
 * @author Nick LaFarge
 * @since 13.0
 */
public class VectorEpochTerm extends IIRVVectorTerm<TimeComponents> {

    /** The length of the IIRV term within the message. */
    public static final int VECTOR_EPOCH_TERM_LENGTH = 9;

    /**
     * Regular expression that ensures the validity of string values for this term.
     * <p>
     * String in the form "hhmmsssss":
     * <ul>
     * <li> hh is 00 to 23: (0[0-9]|1[0-9]|2[0-3])
     * <li> mm is 00 to 59: ([0-5][0-9])
     * <li> sssss is 00000 to 599999: ([0-5][0-9]{4})
     * </ul>
     */
    public static final String VECTOR_EPOCH_TERM_PATTERN = "(0[0-9]|1[0-9]|2[0-3])([0-5][0-9])([0-5][0-9]{4})";

    /**
     * Constructs from a String value.
     *
     * @param stringValue Day of the year (001-366)
     */
    public VectorEpochTerm(final String stringValue) {
        super(VECTOR_EPOCH_TERM_PATTERN, VectorEpochTerm.fromString(stringValue), VECTOR_EPOCH_TERM_LENGTH);
    }

    /**
     * Constructs from a {@link TimeComponents} value.
     *
     * @param timeComponents TimeComponents value to extract vector epoch information from
     */
    public VectorEpochTerm(final TimeComponents timeComponents) {
        super(VECTOR_EPOCH_TERM_PATTERN, timeComponents, VECTOR_EPOCH_TERM_LENGTH);
    }

    /**
     * Constructs from a {@link AbsoluteDate} value.
     *
     * @param absoluteDate AbsoluteDate value to extract vector epoch information from (in UTC)
     * @param utc          UTC time scale
     */
    public VectorEpochTerm(final AbsoluteDate absoluteDate, final UTCScale utc) {
        super(VECTOR_EPOCH_TERM_PATTERN,
            absoluteDate.getComponents(utc).getTime(),
            VECTOR_EPOCH_TERM_LENGTH);
    }

    /**
     * Parses an IIRV string in  format to a {@link TimeComponents} instance.
     * <p>
     * Format is "hhmmsssss" where the implied decimal place is three from the left (hh mm ss.sss)
     *
     * @param iirvString IIRV-formatted string to parse
     * @return time components contained in the input string
     */
    private static TimeComponents fromString(final String iirvString) {
        final int hour = Integer.parseInt(iirvString.substring(0, 2));
        final int minute = Integer.parseInt(iirvString.substring(2, 4));

        // Convert {fullSeconds}.{fractionalSeconds} to seconds
        final double second = DoubleValuedIIRVTerm.computeValueFromString(iirvString.substring(4, 9), 3);

        return new TimeComponents(hour, minute, second);
    }

    /**
     * Gets the two-character hour of the vector epoch.
     *
     * @return hh: hour of the vector epoch
     */
    public String hh() {
        return toEncodedString().substring(0, 2);
    }

    /**
     * Gets the two-character minute of the vector epoch.
     *
     * @return mm: minute of the vector epoch
     */
    public String mm() {
        return toEncodedString().substring(2, 4);
    }

    /**
     * Gets the two-character second of the vector epoch.
     *
     * @return ss: second of the vector epoch
     */
    public String ss() {
        return toEncodedString().substring(4, 6);
    }


    /** {@inheritDoc} */
    @Override
    public String toEncodedString(final TimeComponents value) {

        final DecimalFormat secondsFormat = new DecimalFormat("00.000", new DecimalFormatSymbols(Locale.US));
        final String ss_sss = secondsFormat.format(value.getSecond());

        // Edge case: 60th second doesn't make sense... Round up the hour instead
        if (ss_sss.charAt(0) == '6') {
            final int nextSecond = 0;
            int nextMinute = value.getMinute() + 1;
            int nextHour = value.getHour();
            if (nextMinute == 60) {
                nextMinute = 0;
                nextHour++;
                if (nextHour == 24) {
                    nextHour = 0;
                }
            }
            return toEncodedString(new TimeComponents(nextHour, nextMinute, nextSecond));
        }

        return String.format("%02d%02d%s",
            value.getHour(),
            value.getMinute(),
            ss_sss.replace(".", "")
        );
    }
}