package org.apache.turbine.services.localization;
   
   
   import org.apache.commons.lang3.StringUtils;
   import org.apache.logging.log4j.LogManager;
   import org.apache.logging.log4j.Logger;
   import org.apache.turbine.Turbine;
   import org.apache.turbine.services.TurbineBaseService;
   
  import java.time.ZoneId;
  import java.time.format.DateTimeFormatter;
  import java.time.format.DateTimeParseException;
  import java.time.temporal.TemporalAccessor;
  import java.util.Locale;
  
  /**
   * This service is used to format {@link TemporalAccessor} and
   * {@link #map(String, DateTimeFormatter, Locale)} (different falvors)
   * objects into strings.
   *
   * The methods may throw {@link java.time.temporal.UnsupportedTemporalTypeException} or
   * {@link DateTimeParseException}.
   * if the source and the target format do not match appropriately.
   *
   */
  public class DateTimeFormatterService
          extends TurbineBaseService implements DateTimeFormatterInterface {
  
      public static String SERVICE_NAME = "DateTimeFormatterService";
  
      public static String ROLE = DateTimeFormatterService.class.getName();
  
      /** Default date format. find supporrted formats in {@link DateTimeFormatterService} */
      private static final String DATE_TIME_FORMAT_DEFAULT = "MM/dd/yyyy";
  
      /**
       * Property tag for the date format that is to be used for the web
       * application.
       */
      private static final String DATE_TIME_FORMAT_KEY = "tool.datetimeTool.format";
  
      private String dateTimeFormatPattern = null;
      
      private DateTimeFormatter defaultFormat = null;
  
      @Override
      public DateTimeFormatter getDefaultFormat()
      {
          return defaultFormat;
      }
  
      @Override
      public String getDateTimeFormatPattern() {
          return dateTimeFormatPattern;
      }
  
      private static final Logger log = LogManager.getLogger(DateTimeFormatterService.class);
  
      /**
       * Initialize the service.
       *
       * the {@link #defaultFormat} from {@link #dateTimeFormatPattern} is initialized with
       * the default Locale {@link Locale#getDefault()} and default zone: {@link ZoneId#systemDefault()}.
       *
       */
      @Override
      public void init()
      {
          dateTimeFormatPattern = Turbine.getConfiguration()
                  .getString(DATE_TIME_FORMAT_KEY, DATE_TIME_FORMAT_DEFAULT);
          defaultFormat = DateTimeFormatter.ofPattern(dateTimeFormatPattern)
                  .withLocale(Locale.getDefault()).withZone(ZoneId.systemDefault());
  
          log.info("Initialized DateTimeFormatterService with pattern {}, locale {} and zone {}",
                  dateTimeFormatPattern, defaultFormat.getLocale(), defaultFormat.getZone());
          setInit(true);
      }
  
      @Override
      public <T extends TemporalAccessor> String format(T temporalAccessor)
      {
          return defaultFormat.format(temporalAccessor);
      }
  
      @Override
      public <T extends TemporalAccessor> String format(T temporalAccessor, String dateFormatString)
      {
          return format(temporalAccessor, dateFormatString, null);
      }
  
      @Override
      public <T extends TemporalAccessor> String format(T temporalAccessor, String dateFormatString, Locale locale)
      {
          String result = null;
  
          if (StringUtils.isEmpty(dateFormatString) || temporalAccessor == null)
          {
              result = "";
          }
         else
         {
             DateTimeFormatter dtf = DateTimeFormatter.ofPattern(dateFormatString);
             if (locale != null)
             {
                 dtf.withLocale(locale);
             }
             result = dtf.format(temporalAccessor);
         }
         return result;
     }
     
     @Override
     public String map(String src, String outgoingFormatPattern, Locale locale, String incomingFormatPattern)
     {
         if (StringUtils.isEmpty(src) || outgoingFormatPattern == null)
         {
             return "";
         }
         if (incomingFormatPattern == null)
         {
             incomingFormatPattern = dateTimeFormatPattern;
         }
         if (incomingFormatPattern.equals( outgoingFormatPattern )) {
             return "";
         }
         DateTimeFormatter incomingFormat = DateTimeFormatter.ofPattern(incomingFormatPattern);
         DateTimeFormatter outgoingFormat = DateTimeFormatter.ofPattern(outgoingFormatPattern);
         if (locale != null)
         {
             outgoingFormat = outgoingFormat.withLocale( locale );
             //incomingFormat = incomingFormat.withLocale( locale );
         }
         return map( src, outgoingFormat, locale, incomingFormat );
     }
 
     @Override
     public String map(String src, DateTimeFormatter outgoingFormat, Locale locale,
                       DateTimeFormatter incomingFormat)
     {
         if (StringUtils.isEmpty(src) || outgoingFormat == null)
         {
             return "";
         }
         if (incomingFormat == null)
         {
             incomingFormat = defaultFormat;
         }
         if (incomingFormat.equals( outgoingFormat )) {
             return "";
         }
         if (locale != null)
         {
             outgoingFormat = outgoingFormat.withLocale( locale );
             //incomingFormat = incomingFormat.withLocale( locale );
         }
         return  outgoingFormat.format(
                 incomingFormat.parse( src ));
     }
 
     @Override
     public String mapTo(String src, DateTimeFormatter outgoingFormat)
     {
         return map( src, outgoingFormat, null, defaultFormat );
     }
 
     @Override
     public String mapFrom(String src, DateTimeFormatter incomingFormat)
     {
         return map( src, defaultFormat, null, incomingFormat );
     }
 
     @Override
     public String map(String src, DateTimeFormatter outgoingFormat, Locale locale)
     {
         return map( src, outgoingFormat, locale, defaultFormat );
     }
 }