// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

/// This contains internal implementation details of the date formatting code
/// which are exposed as public functions because they must be called by other
/// libraries in order to configure the source for the locale data. We don't
/// want them exposed as public API functions in the date formatting library, so
/// they are put in a separate library here. These are for internal use
/// only. User code should import one of the `date_symbol_data...` libraries and
/// call the `initializeDateFormatting` method exposed there.

library date_format_internal;

import '../date_symbols.dart';
import 'intl_helpers.dart';

/// This holds the symbols to be used for date/time formatting, indexed
/// by locale. Note that it will be set differently during initialization,
/// depending on what implementation we are using. By default, it is initialized
/// to an instance of UninitializedLocaleData, so any attempt to use it will
/// result in an informative error message.
// TODO(alanknight): Have a valid type for this. Currently it can be an
// UninitializedLocaleData, Map, or LazyLocaleData.
dynamic get dateTimeSymbols => _dateTimeSymbols;

/// Set the dateTimeSymbols and invalidate cache.
set dateTimeSymbols(dynamic symbols) {
  // With all the mechanisms we have now this should be sufficient. We can
  // have an UninitializedLocaleData which gives us the fallback locale, but
  // when we replace it we invalidate. With a LazyLocaleData we won't change
  // the results for a particular locale, it will just go from throwing to
  // being available. With a Map everything is available.
  _dateTimeSymbols = symbols;
  cachedDateSymbols = null;
  lastDateSymbolLocale = null;
}

dynamic _dateTimeSymbols =
    UninitializedLocaleData('initializeDateFormatting(<locale>)', en_USSymbols);

/// Cache the last used symbols to reduce repeated lookups.
DateSymbols? cachedDateSymbols;

/// Which locale was last used for symbol lookup.
String? lastDateSymbolLocale;

/// This holds the patterns used for date/time formatting, indexed
/// by locale. Note that it will be set differently during initialization,
/// depending on what implementation we are using. By default, it is initialized
/// to an instance of UninitializedLocaleData, so any attempt to use it will
/// result in an informative error message.
// TODO(alanknight): Have a valid type for this. Currently it can be an
// UninitializedLocaleData, Map, or LazyLocaleData.
dynamic dateTimePatterns = UninitializedLocaleData(
    'initializeDateFormatting(<locale>)', en_USPatterns);

/// Initialize the symbols dictionary. This should be passed a function that
/// creates and returns the symbol data. We take a function so that if
/// initializing the data is an expensive operation it need only be done once,
/// no matter how many times this method is called.
void initializeDateSymbols(Function symbols) {
  if (dateTimeSymbols is UninitializedLocaleData<dynamic>) {
    dateTimeSymbols = symbols();
  }
}

/// Initialize the patterns dictionary. This should be passed a function that
/// creates and returns the pattern data. We take a function so that if
/// initializing the data is an expensive operation it need only be done once,
/// no matter how many times this method is called.
void initializeDatePatterns(Function patterns) {
  if (dateTimePatterns is UninitializedLocaleData<dynamic>) {
    dateTimePatterns = patterns();
  }
}

Future<dynamic> initializeIndividualLocaleDateFormatting(Function init) {
  return init(dateTimeSymbols, dateTimePatterns);
}