/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "DateTimeFormat.h"
#include "nsCOMPtr.h"
#include "nsIServiceManager.h"
#include "mozilla/intl/LocaleService.h"
#include "OSPreferences.h"
#include "mozIOSPreferences.h"
#include "unicode/udatpg.h"

namespace mozilla {
using namespace mozilla::intl;

nsCString* DateTimeFormat::mLocale = nullptr;

/*static*/ nsresult DateTimeFormat::Initialize() {
  if (mLocale) {
    return NS_OK;
  }

  mLocale = new nsCString();
  AutoTArray<nsCString, 10> regionalPrefsLocales;
  intl::LocaleService::GetInstance()->GetRegionalPrefsLocales(
      regionalPrefsLocales);
  mLocale->Assign(regionalPrefsLocales[0]);

  return NS_OK;
}

// performs a locale sensitive date formatting operation on the PRTime parameter
/*static*/ nsresult DateTimeFormat::FormatPRTime(
    const nsDateFormatSelector aDateFormatSelector,
    const nsTimeFormatSelector aTimeFormatSelector, const PRTime aPrTime,
    nsAString& aStringOut) {
  return FormatUDateTime(aDateFormatSelector, aTimeFormatSelector,
                         (aPrTime / PR_USEC_PER_MSEC), nullptr, aStringOut);
}

// performs a locale sensitive date formatting operation on the PRExplodedTime
// parameter
/*static*/ nsresult DateTimeFormat::FormatPRExplodedTime(
    const nsDateFormatSelector aDateFormatSelector,
    const nsTimeFormatSelector aTimeFormatSelector,
    const PRExplodedTime* aExplodedTime, nsAString& aStringOut) {
  return FormatUDateTime(aDateFormatSelector, aTimeFormatSelector,
                         (PR_ImplodeTime(aExplodedTime) / PR_USEC_PER_MSEC),
                         &(aExplodedTime->tm_params), aStringOut);
}

// performs a locale sensitive date formatting operation on the UDate parameter
/*static*/ nsresult DateTimeFormat::FormatUDateTime(
    const nsDateFormatSelector aDateFormatSelector,
    const nsTimeFormatSelector aTimeFormatSelector, const UDate aUDateTime,
    const PRTimeParameters* aTimeParameters, nsAString& aStringOut) {
  const int32_t DATETIME_FORMAT_INITIAL_LEN = 127;
  int32_t dateTimeLen = 0;
  nsresult rv = NS_OK;

  // return, nothing to format
  if (aDateFormatSelector == kDateFormatNone &&
      aTimeFormatSelector == kTimeFormatNone) {
    aStringOut.Truncate();
    return NS_OK;
  }

  // set up locale data
  rv = Initialize();

  if (NS_FAILED(rv)) {
    return rv;
  }

  // Get the date style for the formatter.
  nsAutoString skeletonDate;
  nsAutoString patternDate;
  bool haveSkeleton = true;
  switch (aDateFormatSelector) {
    case kDateFormatLong:
      rv = OSPreferences::GetInstance()->GetDateTimePattern(
          mozIOSPreferences::dateTimeFormatStyleLong,
          mozIOSPreferences::dateTimeFormatStyleNone,
          nsDependentCString(mLocale->get()), patternDate);
      NS_ENSURE_SUCCESS(rv, rv);
      haveSkeleton = false;
      break;
    case kDateFormatShort:
      rv = OSPreferences::GetInstance()->GetDateTimePattern(
          mozIOSPreferences::dateTimeFormatStyleShort,
          mozIOSPreferences::dateTimeFormatStyleNone,
          nsDependentCString(mLocale->get()), patternDate);
      NS_ENSURE_SUCCESS(rv, rv);
      haveSkeleton = false;
      break;
    case kDateFormatYearMonth:
      skeletonDate.AssignLiteral("yyyyMM");
      break;
    case kDateFormatYearMonthLong:
      skeletonDate.AssignLiteral("yyyyMMMM");
      break;
    case kDateFormatMonthLong:
      skeletonDate.AssignLiteral("MMMM");
      break;
    case kDateFormatWeekday:
      skeletonDate.AssignLiteral("EEE");
      break;
    case kDateFormatNone:
      haveSkeleton = false;
      break;
    default:
      NS_ERROR("Unknown nsDateFormatSelector");
      return NS_ERROR_ILLEGAL_VALUE;
  }

  UErrorCode status = U_ZERO_ERROR;
  if (haveSkeleton) {
    // Get pattern for skeleton.
    UDateTimePatternGenerator* patternGenerator =
        udatpg_open(mLocale->get(), &status);
    if (U_SUCCESS(status)) {
      int32_t patternLength;
      patternDate.SetLength(DATETIME_FORMAT_INITIAL_LEN);
      patternLength = udatpg_getBestPattern(
          patternGenerator,
          reinterpret_cast<const UChar*>(skeletonDate.BeginReading()),
          skeletonDate.Length(),
          reinterpret_cast<UChar*>(patternDate.BeginWriting()),
          DATETIME_FORMAT_INITIAL_LEN, &status);
      patternDate.SetLength(patternLength);

      if (status == U_BUFFER_OVERFLOW_ERROR) {
        status = U_ZERO_ERROR;
        udatpg_getBestPattern(
            patternGenerator,
            reinterpret_cast<const UChar*>(skeletonDate.BeginReading()),
            skeletonDate.Length(),
            reinterpret_cast<UChar*>(patternDate.BeginWriting()), patternLength,
            &status);
      }
    }
    udatpg_close(patternGenerator);
  }

  // Get the time style for the formatter.
  nsAutoString patternTime;
  switch (aTimeFormatSelector) {
    case kTimeFormatSeconds:
      rv = OSPreferences::GetInstance()->GetDateTimePattern(
          mozIOSPreferences::dateTimeFormatStyleNone,
          mozIOSPreferences::dateTimeFormatStyleLong,
          nsDependentCString(mLocale->get()), patternTime);
      NS_ENSURE_SUCCESS(rv, rv);
      break;
    case kTimeFormatNoSeconds:
      rv = OSPreferences::GetInstance()->GetDateTimePattern(
          mozIOSPreferences::dateTimeFormatStyleNone,
          mozIOSPreferences::dateTimeFormatStyleShort,
          nsDependentCString(mLocale->get()), patternTime);
      NS_ENSURE_SUCCESS(rv, rv);
      break;
    case kTimeFormatNone:
      break;
    default:
      NS_ERROR("Unknown nsTimeFormatSelector");
      return NS_ERROR_ILLEGAL_VALUE;
  }

  nsAutoString pattern;
  if (patternTime.Length() == 0) {
    pattern.Assign(patternDate);
  } else if (patternDate.Length() == 0) {
    pattern.Assign(patternTime);
  } else {
    OSPreferences::GetDateTimeConnectorPattern(
        nsDependentCString(mLocale->get()), pattern);
    int32_t index = pattern.Find("{1}");
    if (index != kNotFound) pattern.Replace(index, 3, patternDate);
    index = pattern.Find("{0}");
    if (index != kNotFound) pattern.Replace(index, 3, patternTime);
  }

  // Generate date/time string.
  nsAutoString timeZoneID(u"GMT");
  if (aTimeParameters) {
    int32_t totalOffsetMinutes =
        (aTimeParameters->tp_gmt_offset + aTimeParameters->tp_dst_offset) / 60;
    if (totalOffsetMinutes != 0) {
      char sign = totalOffsetMinutes < 0 ? '-' : '+';
      int32_t hours = abs(totalOffsetMinutes) / 60;
      int32_t minutes = abs(totalOffsetMinutes) % 60;
      timeZoneID.AppendPrintf("%c%02d:%02d", sign, hours, minutes);
    }
  }

  UDateFormat* dateTimeFormat;
  if (aTimeParameters) {
    dateTimeFormat =
        udat_open(UDAT_PATTERN, UDAT_PATTERN, mLocale->get(),
                  reinterpret_cast<const UChar*>(timeZoneID.BeginReading()),
                  timeZoneID.Length(),
                  reinterpret_cast<const UChar*>(pattern.BeginReading()),
                  pattern.Length(), &status);
  } else {
    dateTimeFormat =
        udat_open(UDAT_PATTERN, UDAT_PATTERN, mLocale->get(), nullptr, -1,
                  reinterpret_cast<const UChar*>(pattern.BeginReading()),
                  pattern.Length(), &status);
  }

  if (U_SUCCESS(status) && dateTimeFormat) {
    aStringOut.SetLength(DATETIME_FORMAT_INITIAL_LEN);
    dateTimeLen =
        udat_format(dateTimeFormat, aUDateTime,
                    reinterpret_cast<UChar*>(aStringOut.BeginWriting()),
                    DATETIME_FORMAT_INITIAL_LEN, nullptr, &status);
    aStringOut.SetLength(dateTimeLen);

    if (status == U_BUFFER_OVERFLOW_ERROR) {
      status = U_ZERO_ERROR;
      udat_format(dateTimeFormat, aUDateTime,
                  reinterpret_cast<UChar*>(aStringOut.BeginWriting()),
                  dateTimeLen, nullptr, &status);
    }
  }

  if (U_FAILURE(status)) {
    rv = NS_ERROR_FAILURE;
  }

  if (dateTimeFormat) {
    udat_close(dateTimeFormat);
  }

  return rv;
}

/*static*/ void DateTimeFormat::Shutdown() {
  if (mLocale) {
    delete mLocale;
  }
}

}  // namespace mozilla