/*
    * Oceanus: Java Utilities
    * Copyright 2012-2026. Tony Washer
    *
    * Licensed 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 io.github.tonywasher.joceanus.oceanus.date;
  
  import io.github.tonywasher.joceanus.oceanus.base.OceanusLocale;
  import io.github.tonywasher.joceanus.oceanus.convert.OceanusDataConverter;
  import io.github.tonywasher.joceanus.oceanus.event.OceanusEventManager;
  import io.github.tonywasher.joceanus.oceanus.event.OceanusEventRegistrar;
  import io.github.tonywasher.joceanus.oceanus.event.OceanusEventRegistrar.OceanusEventProvider;
  
  import java.text.SimpleDateFormat;
  import java.time.LocalDate;
  import java.time.format.DateTimeFormatter;
  import java.time.format.DateTimeParseException;
  import java.util.Locale;
  
  /**
   * Formatter for Date objects.
   *
   * @author Tony Washer
   */
  public class OceanusDateFormatter
          implements OceanusEventProvider<OceanusDateEvent> {
      /**
       * Date Byte length.
       */
      public static final int BYTE_LEN = Long.BYTES;
  
      /**
       * As of Java 16.0.2 the short format for September is Sept instead of Sep.
       */
      private static final int PATCH_JAVA_VER = 16;
  
      /**
       * As of Java 16.0.2 the short format for September is Sept instead of Sep.
       */
      private static final String PATCH_SEPT_NEW = "-Sept-";
  
      /**
       * As of Java 16.0.2 the short format for September is Sept instead of Sep.
       */
      private static final String PATCH_SEPT_OLD = "-Sep-";
  
      /**
       * The default format.
       */
      private static final String DEFAULT_FORMAT = "dd-MMM-yyyy";
  
      /**
       * One hundred years.
       */
      private static final int YEARS_CENTURY = 100;
  
      /**
       * The Event Manager.
       */
      private final OceanusEventManager<OceanusDateEvent> theEventManager;
  
      /**
       * The locale.
       */
      private Locale theLocale;
  
      /**
       * The Simple Date format for the locale and format string.
       */
      private String theFormat;
  
      /**
       * The Simple Date format for the locale and format string.
       */
      private SimpleDateFormat theDateFormat;
  
      /**
       * The DateTime format for the locale and format string.
       */
      private DateTimeFormatter theLocalDateFormat;
  
      /**
       * Constructor.
       */
      public OceanusDateFormatter() {
          /* Use default locale */
          this(OceanusLocale.getDefaultLocale());
      }
 
     /**
      * Constructor.
      *
      * @param pLocale the locale
      */
     public OceanusDateFormatter(final Locale pLocale) {
         /* Store locale */
         theLocale = pLocale;
         theEventManager = new OceanusEventManager<>();
         setFormat(DEFAULT_FORMAT);
     }
 
     @Override
     public OceanusEventRegistrar<OceanusDateEvent> getEventRegistrar() {
         return theEventManager.getEventRegistrar();
     }
 
     /**
      * Set the date format.
      *
      * @param pFormat the format string
      */
     public final void setFormat(final String pFormat) {
         /* If the format is the same */
         if (pFormat.equals(theFormat)) {
             /* Ignore */
             return;
         }
 
         /* Create the simple date format */
         theFormat = pFormat;
         theDateFormat = new SimpleDateFormat(theFormat, theLocale);
         theLocalDateFormat = DateTimeFormatter.ofPattern(theFormat, theLocale);
 
         /* Notify of the change */
         theEventManager.fireEvent(OceanusDateEvent.FORMATCHANGED);
     }
 
     /**
      * Set the locale.
      *
      * @param pLocale the locale
      */
     public final void setLocale(final Locale pLocale) {
         /* If the locale is the same */
         if (theLocale.equals(pLocale)) {
             /* Ignore */
             return;
         }
 
         /* Store the locale */
         theLocale = pLocale;
         final String pFormat = theFormat;
         theFormat = null;
         setFormat(pFormat);
     }
 
     /**
      * Format a local Date.
      *
      * @param pDate the date to format
      * @return the formatted date
      */
     public String formatLocalDate(final LocalDate pDate) {
         /* Handle null */
         if (pDate == null) {
             return null;
         }
 
         /* Format the date */
         return pDate.format(theLocalDateFormat);
     }
 
     /**
      * Format a Date.
      *
      * @param pDate the date to format
      * @return the formatted date
      */
     public String formatDate(final OceanusDate pDate) {
         /* Handle null */
         if (pDate == null) {
             return null;
         }
 
         /* Format the date */
         return formatLocalDate(pDate.getDate());
     }
 
     /**
      * Format a DateRange.
      *
      * @param pRange the range to format
      * @return the formatted date
      */
     public String formatDateRange(final OceanusDateRange pRange) {
         /* Handle null */
         if (pRange == null) {
             return null;
         }
 
         /* Access components */
         final OceanusDate myStart = pRange.getStart();
         final OceanusDate myEnd = pRange.getEnd();
 
         /* Build range description */
         return ((myStart == null)
                 ? OceanusDateRange.DESC_UNBOUNDED
                 : formatDate(myStart))
                 + OceanusDateRange.CHAR_BLANK
                 + OceanusDateRange.DESC_LINK
                 + OceanusDateRange.CHAR_BLANK
                 + ((myEnd == null)
                 ? OceanusDateRange.DESC_UNBOUNDED
                 : formatDate(myEnd));
     }
 
     /**
      * Parse LocalDate.
      *
      * @param pValue Formatted Date
      * @return the Date
      * @throws IllegalArgumentException on error
      */
     public LocalDate parseLocalDate(final String pValue) {
         /* Parse the date */
         try {
             return LocalDate.parse(pValue, theLocalDateFormat);
         } catch (DateTimeParseException e) {
             /* Handle Patch for Java 16.0.2 change for September */
             final int myVersion = Runtime.version().feature();
             if (pValue.contains(PATCH_SEPT_OLD)
                     && myVersion >= PATCH_JAVA_VER) {
                 return parsePatchedLocalDate(pValue.replace(PATCH_SEPT_OLD, PATCH_SEPT_NEW));
             }
             if (pValue.contains(PATCH_SEPT_NEW)
                     && Runtime.version().feature() < PATCH_JAVA_VER) {
                 return parsePatchedLocalDate(pValue.replace(PATCH_SEPT_NEW, PATCH_SEPT_OLD));
             }
 
             /* throw exception */
             throw new IllegalArgumentException("Invalid date: "
                     + pValue, e);
         }
     }
 
     /**
      * Parse LocalDate.
      *
      * @param pValue Formatted Date
      * @return the Date
      * @throws IllegalArgumentException on error
      */
     private LocalDate parsePatchedLocalDate(final String pValue) {
         /* Parse the date */
         try {
             return LocalDate.parse(pValue, theLocalDateFormat);
         } catch (DateTimeParseException e) {
             /* throw exception */
             throw new IllegalArgumentException("Invalid date: "
                     + pValue, e);
         }
     }
 
     /**
      * /**
      * Parse Date.
      *
      * @param pValue Formatted Date
      * @return the DateDay
      * @throws IllegalArgumentException on error
      */
     public OceanusDate parseDate(final String pValue) {
         final LocalDate myDate = parseLocalDate(pValue);
         return new OceanusDate(myDate);
     }
 
     /**
      * Parse Date using the passed year as base date.
      * <p>
      * This is used when a two digit year is utilised
      *
      * @param pValue    Formatted DateDay
      * @param pBaseYear the base year
      * @return the DateDay
      * @throws IllegalArgumentException on error
      */
     public OceanusDate parseDateBase(final String pValue,
                                      final int pBaseYear) {
         LocalDate myDate = parseLocalDate(pValue);
         if (myDate.getYear() >= pBaseYear + YEARS_CENTURY) {
             myDate = myDate.minusYears(YEARS_CENTURY);
         }
         return new OceanusDate(myDate);
     }
 
     /**
      * Obtain the locale.
      *
      * @return the locale
      */
     public Locale getLocale() {
         return theLocale;
     }
 
     /**
      * Create a byte array representation of a date.
      *
      * @param pDate the date to process
      * @return the processed date
      */
     public byte[] toBytes(final OceanusDate pDate) {
         final long myEpoch = pDate.getDate().toEpochDay();
         return OceanusDataConverter.longToByteArray(myEpoch);
     }
 
     /**
      * Parse a byte array representation of a date.
      *
      * @param pBuffer the byte representation
      * @return the date
      */
     public OceanusDate fromBytes(final byte[] pBuffer) {
         if (pBuffer == null || pBuffer.length < Long.BYTES) {
             throw new IllegalArgumentException();
         }
         final long myEpoch = OceanusDataConverter.byteArrayToLong(pBuffer);
         final LocalDate myDate = LocalDate.ofEpochDay(myEpoch);
         return new OceanusDate(myDate);
     }
 }