content: /*
   * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  /*
   * Copyright (c) 2012, Stephen Colebourne & Michael Nascimento Santos
   *
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   *  * Redistributions of source code must retain the above copyright notice,
   *    this list of conditions and the following disclaimer.
   *
   *  * Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   *
   *  * Neither the name of JSR-310 nor the names of its contributors
   *    may be used to endorse or promote products derived from this software
   *    without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  
  package java.time.chrono;
  
  import static java.time.temporal.ChronoField.EPOCH_DAY;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InvalidObjectException;
  import java.io.ObjectInputStream;
  import java.io.Serializable;
  import java.security.AccessController;
  import java.security.PrivilegedActionException;
  import java.time.Clock;
  import java.time.DateTimeException;
  import java.time.Instant;
  import java.time.LocalDate;
  import java.time.ZoneId;
  import java.time.format.ResolverStyle;
  import java.time.temporal.ChronoField;
  import java.time.temporal.TemporalAccessor;
  import java.time.temporal.TemporalField;
  import java.time.temporal.ValueRange;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Properties;
  
  import sun.util.logging.PlatformLogger;
  
  /**
   * The Hijrah calendar is a lunar calendar supporting Islamic calendars.
   * <p>
   * The HijrahChronology follows the rules of the Hijrah calendar system. The Hijrah
   * calendar has several variants based on differences in when the new moon is
   * determined to have occurred and where the observation is made.
   * In some variants the length of each month is
   * computed algorithmically from the astronomical data for the moon and earth and
   * in others the length of the month is determined by an authorized sighting
   * of the new moon. For the algorithmically based calendars the calendar
   * can project into the future.
   * For sighting based calendars only historical data from past
   * sightings is available.
   * <p>
   * The length of each month is 29 or 30 days.
   * Ordinary years have 354 days; leap years have 355 days.
   *
   * <p>
   * CLDR and LDML identify variants:
   * <table cellpadding="2" summary="Variants of Hijrah Calendars">
   * <thead>
   * <tr class="tableSubHeadingColor">
   * <th class="colFirst" align="left" >Chronology ID</th>
   * <th class="colFirst" align="left" >Calendar Type</th>
   * <th class="colFirst" align="left" >Locale extension, see {@link java.util.Locale}</th>
   * <th class="colLast" align="left" >Description</th>
   * </tr>
   * </thead>
   * <tbody>
   * <tr class="altColor">
   * <td>Hijrah-umalqura</td>
   * <td>islamic-umalqura</td>
   * <td>ca-islamic-umalqura</td>
   * <td>Islamic - Umm Al-Qura calendar of Saudi Arabia</td>
   * </tr>
   * </tbody>
   * </table>
   * <p>Additional variants may be available through {@link Chronology#getAvailableChronologies()}.
   *
   * <p>Example</p>
   * <p>
   * Selecting the chronology from the locale uses {@link Chronology#ofLocale}
   * to find the Chronology based on Locale supported BCP 47 extension mechanism
   * to request a specific calendar ("ca"). For example,
   * </p>
   * <pre>
   *      Locale locale = Locale.forLanguageTag("en-US-u-ca-islamic-umalqura");
   *      Chronology chrono = Chronology.ofLocale(locale);
   * </pre>
   *
   * @implSpec
   * This class is immutable and thread-safe.
   *
   * @implNote
   * Each Hijrah variant is configured individually. Each variant is defined by a
   * property resource that defines the {@code ID}, the {@code calendar type},
   * the start of the calendar, the alignment with the
   * ISO calendar, and the length of each month for a range of years.
   * The variants are identified in the {@code calendars.properties} file.
   * The new properties are prefixed with {@code "calendars.hijrah."}:
   * <table cellpadding="2" border="0" summary="Configuration of Hijrah Calendar Variants">
   * <thead>
   * <tr class="tableSubHeadingColor">
   * <th class="colFirst" align="left">Property Name</th>
   * <th class="colFirst" align="left">Property value</th>
   * <th class="colLast" align="left">Description </th>
   * </tr>
   * </thead>
   * <tbody>
   * <tr class="altColor">
   * <td>calendars.hijrah.{ID}</td>
   * <td>The property resource defining the {@code {ID}} variant</td>
   * <td>The property resource is located with the {@code calendars.properties} file</td>
   * </tr>
   * <tr class="rowColor">
   * <td>calendars.hijrah.{ID}.type</td>
   * <td>The calendar type</td>
   * <td>LDML defines the calendar type names</td>
   * </tr>
   * </tbody>
   * </table>
   * <p>
   * The Hijrah property resource is a set of properties that describe the calendar.
   * The syntax is defined by {@code java.util.Properties#load(Reader)}.
   * <table cellpadding="2" summary="Configuration of Hijrah Calendar">
   * <thead>
   * <tr class="tableSubHeadingColor">
   * <th class="colFirst" align="left" > Property Name</th>
   * <th class="colFirst" align="left" > Property value</th>
   * <th class="colLast" align="left" > Description </th>
   * </tr>
   * </thead>
   * <tbody>
   * <tr class="altColor">
   * <td>id</td>
   * <td>Chronology Id, for example, "Hijrah-umalqura"</td>
   * <td>The Id of the calendar in common usage</td>
   * </tr>
   * <tr class="rowColor">
   * <td>type</td>
   * <td>Calendar type, for example, "islamic-umalqura"</td>
   * <td>LDML defines the calendar types</td>
   * </tr>
   * <tr class="altColor">
   * <td>version</td>
   * <td>Version, for example: "1.8.0_1"</td>
   * <td>The version of the Hijrah variant data</td>
   * </tr>
   * <tr class="rowColor">
   * <td>iso-start</td>
   * <td>ISO start date, formatted as {@code yyyy-MM-dd}, for example: "1900-04-30"</td>
   * <td>The ISO date of the first day of the minimum Hijrah year.</td>
   * </tr>
   * <tr class="altColor">
   * <td>yyyy - a numeric 4 digit year, for example "1434"</td>
   * <td>The value is a sequence of 12 month lengths,
   * for example: "29 30 29 30 29 30 30 30 29 30 29 29"</td>
   * <td>The lengths of the 12 months of the year separated by whitespace.
   * A numeric year property must be present for every year without any gaps.
   * The month lengths must be between 29-32 inclusive.
   * </td>
   * </tr>
   * </tbody>
   * </table>
   *
   * @since 1.8
   */
  public final class HijrahChronology extends AbstractChronology implements Serializable {
  
      /**
       * The Hijrah Calendar id.
       */
      private final transient String typeId;
      /**
       * The Hijrah calendarType.
       */
      private final transient String calendarType;
      /**
       * Serialization version.
       */
      private static final long serialVersionUID = 3127340209035924785L;
      /**
       * Singleton instance of the Islamic Umm Al-Qura calendar of Saudi Arabia.
       * Other Hijrah chronology variants may be available from
       * {@link Chronology#getAvailableChronologies}.
       */
      public static final HijrahChronology INSTANCE;
      /**
       * Flag to indicate the initialization of configuration data is complete.
       * @see #checkCalendarInit()
       */
      private transient volatile boolean initComplete;
      /**
       * Array of epoch days indexed by Hijrah Epoch month.
       * Computed by {@link #loadCalendarData}.
       */
      private transient int[] hijrahEpochMonthStartDays;
      /**
       * The minimum epoch day of this Hijrah calendar.
       * Computed by {@link #loadCalendarData}.
       */
      private transient int minEpochDay;
      /**
       * The maximum epoch day for which calendar data is available.
       * Computed by {@link #loadCalendarData}.
       */
      private transient int maxEpochDay;
      /**
       * The minimum epoch month.
       * Computed by {@link #loadCalendarData}.
       */
      private transient int hijrahStartEpochMonth;
      /**
       * The minimum length of a month.
       * Computed by {@link #createEpochMonths}.
       */
      private transient int minMonthLength;
      /**
       * The maximum length of a month.
       * Computed by {@link #createEpochMonths}.
       */
      private transient int maxMonthLength;
      /**
       * The minimum length of a year in days.
       * Computed by {@link #createEpochMonths}.
       */
      private transient int minYearLength;
      /**
       * The maximum length of a year in days.
       * Computed by {@link #createEpochMonths}.
       */
      private transient int maxYearLength;
      /**
       * A reference to the properties stored in
       * ${java.home}/lib/calendars.properties
       */
      private final transient static Properties calendarProperties;
  
      /**
       * Prefix of property names for Hijrah calendar variants.
       */
      private static final String PROP_PREFIX = "calendar.hijrah.";
      /**
       * Suffix of property names containing the calendar type of a variant.
       */
      private static final String PROP_TYPE_SUFFIX = ".type";
  
      /**
       * Static initialization of the predefined calendars found in the
       * lib/calendars.properties file.
       */
      static {
          try {
              calendarProperties = sun.util.calendar.BaseCalendar.getCalendarProperties();
          } catch (IOException ioe) {
              throw new InternalError("Can't initialize lib/calendars.properties", ioe);
          }
  
          try {
              INSTANCE = new HijrahChronology("Hijrah-umalqura");
              // Register it by its aliases
              AbstractChronology.registerChrono(INSTANCE, "Hijrah");
              AbstractChronology.registerChrono(INSTANCE, "islamic");
          } catch (DateTimeException ex) {
              // Absence of Hijrah calendar is fatal to initializing this class.
              PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
              logger.severe("Unable to initialize Hijrah calendar: Hijrah-umalqura", ex);
              throw new RuntimeException("Unable to initialize Hijrah-umalqura calendar", ex.getCause());
          }
          registerVariants();
      }
  
      /**
       * For each Hijrah variant listed, create the HijrahChronology and register it.
       * Exceptions during initialization are logged but otherwise ignored.
       */
      private static void registerVariants() {
          for (String name : calendarProperties.stringPropertyNames()) {
              if (name.startsWith(PROP_PREFIX)) {
                  String id = name.substring(PROP_PREFIX.length());
                  if (id.indexOf('.') >= 0) {
                      continue;   // no name or not a simple name of a calendar
                  }
                  if (id.equals(INSTANCE.getId())) {
                      continue;           // do not duplicate the default
                  }
                  try {
                      // Create and register the variant
                      HijrahChronology chrono = new HijrahChronology(id);
                      AbstractChronology.registerChrono(chrono);
                  } catch (DateTimeException ex) {
                      // Log error and continue
                      PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
                      logger.severe("Unable to initialize Hijrah calendar: " + id, ex);
                  }
              }
          }
      }
  
      /**
       * Create a HijrahChronology for the named variant.
       * The resource and calendar type are retrieved from properties
       * in the {@code calendars.properties}.
       * The property names are {@code "calendar.hijrah." + id}
       * and  {@code "calendar.hijrah." + id + ".type"}
       * @param id the id of the calendar
       * @throws DateTimeException if the calendar type is missing from the properties file.
       * @throws IllegalArgumentException if the id is empty
       */
      private HijrahChronology(String id) throws DateTimeException {
          if (id.isEmpty()) {
              throw new IllegalArgumentException("calendar id is empty");
          }
          String propName = PROP_PREFIX + id + PROP_TYPE_SUFFIX;
          String calType = calendarProperties.getProperty(propName);
          if (calType == null || calType.isEmpty()) {
              throw new DateTimeException("calendarType is missing or empty for: " + propName);
          }
          this.typeId = id;
          this.calendarType = calType;
      }
  
      /**
       * Check and ensure that the calendar data has been initialized.
       * The initialization check is performed at the boundary between
       * public and package methods.  If a public calls another public method
       * a check is not necessary in the caller.
       * The constructors of HijrahDate call {@link #getEpochDay} or
       * {@link #getHijrahDateInfo} so every call from HijrahDate to a
       * HijrahChronology via package private methods has been checked.
       *
       * @throws DateTimeException if the calendar data configuration is
       *     malformed or IOExceptions occur loading the data
       */
      private void checkCalendarInit() {
          // Keep this short so it can be inlined for performance
          if (initComplete == false) {
              loadCalendarData();
              initComplete = true;
          }
      }
  
      //-----------------------------------------------------------------------
      /**
       * Gets the ID of the chronology.
       * <p>
       * The ID uniquely identifies the {@code Chronology}. It can be used to
       * lookup the {@code Chronology} using {@link Chronology#of(String)}.
       *
       * @return the chronology ID, non-null
       * @see #getCalendarType()
       */
      @Override
      public String getId() {
          return typeId;
      }
  
      /**
       * Gets the calendar type of the Islamic calendar.
       * <p>
       * The calendar type is an identifier defined by the
       * <em>Unicode Locale Data Markup Language (LDML)</em> specification.
       * It can be used to lookup the {@code Chronology} using {@link Chronology#of(String)}.
       *
       * @return the calendar system type; non-null if the calendar has
       *    a standard type, otherwise null
       * @see #getId()
       */
      @Override
      public String getCalendarType() {
          return calendarType;
      }
  
      //-----------------------------------------------------------------------
      /**
       * Obtains a local date in Hijrah calendar system from the
       * era, year-of-era, month-of-year and day-of-month fields.
       *
       * @param era  the Hijrah era, not null
       * @param yearOfEra  the year-of-era
       * @param month  the month-of-year
       * @param dayOfMonth  the day-of-month
       * @return the Hijrah local date, not null
       * @throws DateTimeException if unable to create the date
       * @throws ClassCastException if the {@code era} is not a {@code HijrahEra}
       */
      @Override
      public HijrahDate date(Era era, int yearOfEra, int month, int dayOfMonth) {
          return date(prolepticYear(era, yearOfEra), month, dayOfMonth);
      }
  
      /**
       * Obtains a local date in Hijrah calendar system from the
       * proleptic-year, month-of-year and day-of-month fields.
       *
       * @param prolepticYear  the proleptic-year
       * @param month  the month-of-year
       * @param dayOfMonth  the day-of-month
       * @return the Hijrah local date, not null
       * @throws DateTimeException if unable to create the date
       */
      @Override
      public HijrahDate date(int prolepticYear, int month, int dayOfMonth) {
          return HijrahDate.of(this, prolepticYear, month, dayOfMonth);
      }
  
      /**
       * Obtains a local date in Hijrah calendar system from the
       * era, year-of-era and day-of-year fields.
       *
       * @param era  the Hijrah era, not null
       * @param yearOfEra  the year-of-era
       * @param dayOfYear  the day-of-year
       * @return the Hijrah local date, not null
       * @throws DateTimeException if unable to create the date
       * @throws ClassCastException if the {@code era} is not a {@code HijrahEra}
       */
      @Override
      public HijrahDate dateYearDay(Era era, int yearOfEra, int dayOfYear) {
          return dateYearDay(prolepticYear(era, yearOfEra), dayOfYear);
      }
  
      /**
       * Obtains a local date in Hijrah calendar system from the
       * proleptic-year and day-of-year fields.
       *
       * @param prolepticYear  the proleptic-year
       * @param dayOfYear  the day-of-year
       * @return the Hijrah local date, not null
       * @throws DateTimeException if the value of the year is out of range,
       *  or if the day-of-year is invalid for the year
       */
      @Override
      public HijrahDate dateYearDay(int prolepticYear, int dayOfYear) {
          HijrahDate date = HijrahDate.of(this, prolepticYear, 1, 1);
          if (dayOfYear > date.lengthOfYear()) {
              throw new DateTimeException("Invalid dayOfYear: " + dayOfYear);
          }
          return date.plusDays(dayOfYear - 1);
      }
  
      /**
       * Obtains a local date in the Hijrah calendar system from the epoch-day.
       *
       * @param epochDay  the epoch day
       * @return the Hijrah local date, not null
       * @throws DateTimeException if unable to create the date
       */
      @Override  // override with covariant return type
      public HijrahDate dateEpochDay(long epochDay) {
          return HijrahDate.ofEpochDay(this, epochDay);
      }
  
      @Override
      public HijrahDate dateNow() {
          return dateNow(Clock.systemDefaultZone());
      }
  
      @Override
      public HijrahDate dateNow(ZoneId zone) {
          return dateNow(Clock.system(zone));
      }
  
      @Override
      public HijrahDate dateNow(Clock clock) {
          return date(LocalDate.now(clock));
      }
  
      @Override
      public HijrahDate date(TemporalAccessor temporal) {
          if (temporal instanceof HijrahDate) {
              return (HijrahDate) temporal;
          }
          return HijrahDate.ofEpochDay(this, temporal.getLong(EPOCH_DAY));
      }
  
      @Override
      @SuppressWarnings("unchecked")
      public ChronoLocalDateTime<HijrahDate> localDateTime(TemporalAccessor temporal) {
          return (ChronoLocalDateTime<HijrahDate>) super.localDateTime(temporal);
      }
  
      @Override
      @SuppressWarnings("unchecked")
      public ChronoZonedDateTime<HijrahDate> zonedDateTime(TemporalAccessor temporal) {
          return (ChronoZonedDateTime<HijrahDate>) super.zonedDateTime(temporal);
      }
  
      @Override
      @SuppressWarnings("unchecked")
      public ChronoZonedDateTime<HijrahDate> zonedDateTime(Instant instant, ZoneId zone) {
          return (ChronoZonedDateTime<HijrahDate>) super.zonedDateTime(instant, zone);
      }
  
      //-----------------------------------------------------------------------
      @Override
      public boolean isLeapYear(long prolepticYear) {
          checkCalendarInit();
          if (prolepticYear < getMinimumYear() || prolepticYear > getMaximumYear()) {
              return false;
          }
          int len = getYearLength((int) prolepticYear);
          return (len > 354);
      }
  
      @Override
      public int prolepticYear(Era era, int yearOfEra) {
          if (era instanceof HijrahEra == false) {
              throw new ClassCastException("Era must be HijrahEra");
          }
          return yearOfEra;
      }
  
      @Override
      public HijrahEra eraOf(int eraValue) {
          switch (eraValue) {
              case 1:
                  return HijrahEra.AH;
              default:
                  throw new DateTimeException("invalid Hijrah era");
          }
      }
  
      @Override
      public List<Era> eras() {
          return Arrays.<Era>asList(HijrahEra.values());
      }
  
      //-----------------------------------------------------------------------
      @Override
      public ValueRange range(ChronoField field) {
          checkCalendarInit();
          if (field instanceof ChronoField) {
              ChronoField f = field;
              switch (f) {
                  case DAY_OF_MONTH:
                      return ValueRange.of(1, 1, getMinimumMonthLength(), getMaximumMonthLength());
                  case DAY_OF_YEAR:
                      return ValueRange.of(1, getMaximumDayOfYear());
                  case ALIGNED_WEEK_OF_MONTH:
                      return ValueRange.of(1, 5);
                  case YEAR:
                  case YEAR_OF_ERA:
                      return ValueRange.of(getMinimumYear(), getMaximumYear());
                  case ERA:
                      return ValueRange.of(1, 1);
                  default:
                      return field.range();
              }
          }
          return field.range();
      }
  
      //-----------------------------------------------------------------------
      @Override  // override for return type
      public HijrahDate resolveDate(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
          return (HijrahDate) super.resolveDate(fieldValues, resolverStyle);
      }
  
      //-----------------------------------------------------------------------
      /**
       * Check the validity of a year.
       *
       * @param prolepticYear the year to check
       */
      int checkValidYear(long prolepticYear) {
          if (prolepticYear < getMinimumYear() || prolepticYear > getMaximumYear()) {
              throw new DateTimeException("Invalid Hijrah year: " + prolepticYear);
          }
          return (int) prolepticYear;
      }
  
      void checkValidDayOfYear(int dayOfYear) {
          if (dayOfYear < 1 || dayOfYear > getMaximumDayOfYear()) {
              throw new DateTimeException("Invalid Hijrah day of year: " + dayOfYear);
          }
      }
  
      void checkValidMonth(int month) {
          if (month < 1 || month > 12) {
              throw new DateTimeException("Invalid Hijrah month: " + month);
          }
      }
  
      //-----------------------------------------------------------------------
      /**
       * Returns an array containing the Hijrah year, month and day
       * computed from the epoch day.
       *
       * @param epochDay  the EpochDay
       * @return int[0] = YEAR, int[1] = MONTH, int[2] = DATE
       */
      int[] getHijrahDateInfo(int epochDay) {
          checkCalendarInit();    // ensure that the chronology is initialized
          if (epochDay < minEpochDay || epochDay >= maxEpochDay) {
              throw new DateTimeException("Hijrah date out of range");
          }
  
          int epochMonth = epochDayToEpochMonth(epochDay);
          int year = epochMonthToYear(epochMonth);
          int month = epochMonthToMonth(epochMonth);
          int day1 = epochMonthToEpochDay(epochMonth);
          int date = epochDay - day1; // epochDay - dayOfEpoch(year, month);
  
          int dateInfo[] = new int[3];
          dateInfo[0] = year;
          dateInfo[1] = month + 1; // change to 1-based.
          dateInfo[2] = date + 1; // change to 1-based.
          return dateInfo;
      }
  
      /**
       * Return the epoch day computed from Hijrah year, month, and day.
       *
       * @param prolepticYear the year to represent, 0-origin
       * @param monthOfYear the month-of-year to represent, 1-origin
       * @param dayOfMonth the day-of-month to represent, 1-origin
       * @return the epoch day
       */
      long getEpochDay(int prolepticYear, int monthOfYear, int dayOfMonth) {
          checkCalendarInit();    // ensure that the chronology is initialized
          checkValidMonth(monthOfYear);
          int epochMonth = yearToEpochMonth(prolepticYear) + (monthOfYear - 1);
          if (epochMonth < 0 || epochMonth >= hijrahEpochMonthStartDays.length) {
              throw new DateTimeException("Invalid Hijrah date, year: " +
                      prolepticYear +  ", month: " + monthOfYear);
          }
          if (dayOfMonth < 1 || dayOfMonth > getMonthLength(prolepticYear, monthOfYear)) {
              throw new DateTimeException("Invalid Hijrah day of month: " + dayOfMonth);
          }
          return epochMonthToEpochDay(epochMonth) + (dayOfMonth - 1);
      }
  
      /**
       * Returns day of year for the year and month.
       *
       * @param prolepticYear a proleptic year
       * @param month a month, 1-origin
       * @return the day of year, 1-origin
       */
      int getDayOfYear(int prolepticYear, int month) {
          return yearMonthToDayOfYear(prolepticYear, (month - 1));
      }
  
      /**
       * Returns month length for the year and month.
       *
       * @param prolepticYear a proleptic year
       * @param monthOfYear a month, 1-origin.
       * @return the length of the month
       */
      int getMonthLength(int prolepticYear, int monthOfYear) {
          int epochMonth = yearToEpochMonth(prolepticYear) + (monthOfYear - 1);
          if (epochMonth < 0 || epochMonth >= hijrahEpochMonthStartDays.length) {
              throw new DateTimeException("Invalid Hijrah date, year: " +
                      prolepticYear +  ", month: " + monthOfYear);
          }
          return epochMonthLength(epochMonth);
      }
  
      /**
       * Returns year length.
       * Note: The 12th month must exist in the data.
       *
       * @param prolepticYear a proleptic year
       * @return year length in days
       */
      int getYearLength(int prolepticYear) {
          return yearMonthToDayOfYear(prolepticYear, 12);
      }
  
      /**
       * Return the minimum supported Hijrah year.
       *
       * @return the minimum
       */
      int getMinimumYear() {
          return epochMonthToYear(0);
      }
  
      /**
       * Return the maximum supported Hijrah ear.
       *
       * @return the minimum
       */
      int getMaximumYear() {
          return epochMonthToYear(hijrahEpochMonthStartDays.length - 1) - 1;
      }
  
      /**
       * Returns maximum day-of-month.
       *
       * @return maximum day-of-month
       */
      int getMaximumMonthLength() {
          return maxMonthLength;
      }
  
      /**
       * Returns smallest maximum day-of-month.
       *
       * @return smallest maximum day-of-month
       */
      int getMinimumMonthLength() {
          return minMonthLength;
      }
  
      /**
       * Returns maximum day-of-year.
       *
       * @return maximum day-of-year
       */
      int getMaximumDayOfYear() {
          return maxYearLength;
      }
  
      /**
       * Returns smallest maximum day-of-year.
       *
       * @return smallest maximum day-of-year
       */
      int getSmallestMaximumDayOfYear() {
          return minYearLength;
      }
  
      /**
       * Returns the epochMonth found by locating the epochDay in the table. The
       * epochMonth is the index in the table
       *
       * @param epochDay
       * @return The index of the element of the start of the month containing the
       * epochDay.
       */
      private int epochDayToEpochMonth(int epochDay) {
          // binary search
          int ndx = Arrays.binarySearch(hijrahEpochMonthStartDays, epochDay);
          if (ndx < 0) {
              ndx = -ndx - 2;
          }
          return ndx;
      }
  
      /**
       * Returns the year computed from the epochMonth
       *
       * @param epochMonth the epochMonth
       * @return the Hijrah Year
       */
      private int epochMonthToYear(int epochMonth) {
          return (epochMonth + hijrahStartEpochMonth) / 12;
      }
  
      /**
       * Returns the epochMonth for the Hijrah Year.
       *
       * @param year the HijrahYear
       * @return the epochMonth for the beginning of the year.
       */
      private int yearToEpochMonth(int year) {
          return (year * 12) - hijrahStartEpochMonth;
      }
  
      /**
       * Returns the Hijrah month from the epochMonth.
       *
       * @param epochMonth the epochMonth
       * @return the month of the Hijrah Year
       */
      private int epochMonthToMonth(int epochMonth) {
          return (epochMonth + hijrahStartEpochMonth) % 12;
      }
  
      /**
       * Returns the epochDay for the start of the epochMonth.
       *
       * @param epochMonth the epochMonth
       * @return the epochDay for the start of the epochMonth.
       */
      private int epochMonthToEpochDay(int epochMonth) {
          return hijrahEpochMonthStartDays[epochMonth];
  
      }
  
      /**
       * Returns the day of year for the requested HijrahYear and month.
       *
       * @param prolepticYear the Hijrah year
       * @param month the Hijrah month
       * @return the day of year for the start of the month of the year
       */
      private int yearMonthToDayOfYear(int prolepticYear, int month) {
          int epochMonthFirst = yearToEpochMonth(prolepticYear);
          return epochMonthToEpochDay(epochMonthFirst + month)
                  - epochMonthToEpochDay(epochMonthFirst);
      }
  
      /**
       * Returns the length of the epochMonth. It is computed from the start of
       * the following month minus the start of the requested month.
       *
       * @param epochMonth the epochMonth; assumed to be within range
       * @return the length in days of the epochMonth
       */
      private int epochMonthLength(int epochMonth) {
          // The very last entry in the epochMonth table is not the start of a month
          return hijrahEpochMonthStartDays[epochMonth + 1]
                  - hijrahEpochMonthStartDays[epochMonth];
      }
  
      //-----------------------------------------------------------------------
      private static final String KEY_ID = "id";
      private static final String KEY_TYPE = "type";
      private static final String KEY_VERSION = "version";
      private static final String KEY_ISO_START = "iso-start";
  
      /**
       * Return the configuration properties from the resource.
       * <p>
       * The default location of the variant configuration resource is:
       * <pre>
       *   "$java.home/lib/" + resource-name
       * </pre>
       *
       * @param resource the name of the calendar property resource
       * @return a Properties containing the properties read from the resource.
       * @throws Exception if access to the property resource fails
       */
      private static Properties readConfigProperties(final String resource) throws Exception {
          // Android-changed: Load system resources.
          Properties props = new Properties();
          try (InputStream is = ClassLoader.getSystemResourceAsStream(resource)) {
              props.load(is);
          }
          return props;
      }
  
      /**
       * Loads and processes the Hijrah calendar properties file for this calendarType.
       * The starting Hijrah date and the corresponding ISO date are
       * extracted and used to calculate the epochDate offset.
       * The version number is identified and ignored.
       * Everything else is the data for a year with containing the length of each
       * of 12 months.
       *
       * @throws DateTimeException if initialization of the calendar data from the
       *     resource fails
       */
      private void loadCalendarData() {
          try {
              String resourceName = calendarProperties.getProperty(PROP_PREFIX + typeId);
              Objects.requireNonNull(resourceName, "Resource missing for calendar: " + PROP_PREFIX + typeId);
              Properties props = readConfigProperties(resourceName);
  
              Map<Integer, int[]> years = new HashMap<>();
              int minYear = Integer.MAX_VALUE;
              int maxYear = Integer.MIN_VALUE;
              String id = null;
              String type = null;
              String version = null;
              int isoStart = 0;
              for (Map.Entry<Object, Object> entry : props.entrySet()) {
                  String key = (String) entry.getKey();
                  switch (key) {
                      case KEY_ID:
                          id = (String)entry.getValue();
                          break;
                      case KEY_TYPE:
                          type = (String)entry.getValue();
                          break;
                      case KEY_VERSION:
                          version = (String)entry.getValue();
                          break;
                      case KEY_ISO_START: {
                          int[] ymd = parseYMD((String) entry.getValue());
                          isoStart = (int) LocalDate.of(ymd[0], ymd[1], ymd[2]).toEpochDay();
                          break;
                      }
                      default:
                          try {
                              // Everything else is either a year or invalid
                              int year = Integer.valueOf(key);
                              int[] months = parseMonths((String) entry.getValue());
                              years.put(year, months);
                              maxYear = Math.max(maxYear, year);
                              minYear = Math.min(minYear, year);
                          } catch (NumberFormatException nfe) {
                              throw new IllegalArgumentException("bad key: " + key);
                          }
                  }
              }
  
              if (!getId().equals(id)) {
                  throw new IllegalArgumentException("Configuration is for a different calendar: " + id);
              }
              if (!getCalendarType().equals(type)) {
                  throw new IllegalArgumentException("Configuration is for a different calendar type: " + type);
              }
              if (version == null || version.isEmpty()) {
                  throw new IllegalArgumentException("Configuration does not contain a version");
              }
              if (isoStart == 0) {
                  throw new IllegalArgumentException("Configuration does not contain a ISO start date");
              }
  
              // Now create and validate the array of epochDays indexed by epochMonth
              hijrahStartEpochMonth = minYear * 12;
              minEpochDay = isoStart;
              hijrahEpochMonthStartDays = createEpochMonths(minEpochDay, minYear, maxYear, years);
              maxEpochDay = hijrahEpochMonthStartDays[hijrahEpochMonthStartDays.length - 1];
  
              // Compute the min and max year length in days.
              for (int year = minYear; year < maxYear; year++) {
                  int length = getYearLength(year);
                  minYearLength = Math.min(minYearLength, length);
                  maxYearLength = Math.max(maxYearLength, length);
              }
          } catch (Exception ex) {
              // Log error and throw a DateTimeException
              PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
              logger.severe("Unable to initialize Hijrah calendar proxy: " + typeId, ex);
              throw new DateTimeException("Unable to initialize HijrahCalendar: " + typeId, ex);
          }
      }
  
      /**
       * Converts the map of year to month lengths ranging from minYear to maxYear
       * into a linear contiguous array of epochDays. The index is the hijrahMonth
       * computed from year and month and offset by minYear. The value of each
       * entry is the epochDay corresponding to the first day of the month.
       *
       * @param minYear The minimum year for which data is provided
       * @param maxYear The maximum year for which data is provided
       * @param years a Map of year to the array of 12 month lengths
       * @return array of epochDays for each month from min to max
       */
      private int[] createEpochMonths(int epochDay, int minYear, int maxYear, Map<Integer, int[]> years) {
          // Compute the size for the array of dates
          int numMonths = (maxYear - minYear + 1) * 12 + 1;
  
          // Initialize the running epochDay as the corresponding ISO Epoch day
          int epochMonth = 0; // index into array of epochMonths
          int[] epochMonths = new int[numMonths];
          minMonthLength = Integer.MAX_VALUE;
          maxMonthLength = Integer.MIN_VALUE;
  
          // Only whole years are valid, any zero's in the array are illegal
          for (int year = minYear; year <= maxYear; year++) {
              int[] months = years.get(year);// must not be gaps
              for (int month = 0; month < 12; month++) {
                  int length = months[month];
                  epochMonths[epochMonth++] = epochDay;
  
                  if (length < 29 || length > 32) {
                      throw new IllegalArgumentException("Invalid month length in year: " + minYear);
                  }
                  epochDay += length;
                  minMonthLength = Math.min(minMonthLength, length);
                  maxMonthLength = Math.max(maxMonthLength, length);
              }
          }
  
          // Insert the final epochDay
          epochMonths[epochMonth++] = epochDay;
  
          if (epochMonth != epochMonths.length) {
              throw new IllegalStateException("Did not fill epochMonths exactly: ndx = " + epochMonth
                      + " should be " + epochMonths.length);
          }
  
          return epochMonths;
      }
  
      /**
       * Parses the 12 months lengths from a property value for a specific year.
       *
       * @param line the value of a year property
       * @return an array of int[12] containing the 12 month lengths
       * @throws IllegalArgumentException if the number of months is not 12
       * @throws NumberFormatException if the 12 tokens are not numbers
       */
      private int[] parseMonths(String line) {
          int[] months = new int[12];
          String[] numbers = line.split("\\s");
          if (numbers.length != 12) {
              throw new IllegalArgumentException("wrong number of months on line: " + Arrays.toString(numbers) + "; count: " + numbers.length);
          }
          for (int i = 0; i < 12; i++) {
              try {
                  months[i] = Integer.valueOf(numbers[i]);
              } catch (NumberFormatException nfe) {
                  throw new IllegalArgumentException("bad key: " + numbers[i]);
              }
          }
          return months;
      }
  
      /**
       * Parse yyyy-MM-dd into a 3 element array [yyyy, mm, dd].
       *
       * @param string the input string
       * @return the 3 element array with year, month, day
       */
      private int[] parseYMD(String string) {
          // yyyy-MM-dd
          string = string.trim();
          try {
              if (string.charAt(4) != '-' || string.charAt(7) != '-') {
                  throw new IllegalArgumentException("date must be yyyy-MM-dd");
              }
              int[] ymd = new int[3];
              ymd[0] = Integer.valueOf(string.substring(0, 4));
              ymd[1] = Integer.valueOf(string.substring(5, 7));
              ymd[2] = Integer.valueOf(string.substring(8, 10));
              return ymd;
          } catch (NumberFormatException ex) {
              throw new IllegalArgumentException("date must be yyyy-MM-dd", ex);
          }
      }
  
      //-----------------------------------------------------------------------
      /**
       * Writes the Chronology using a
       * <a href="../../../serialized-form.html#java.time.chrono.Ser">dedicated serialized form</a>.
       * @serialData
       * <pre>
       *  out.writeByte(1);     // identifies a Chronology
       *  out.writeUTF(getId());
       * </pre>
       *
       * @return the instance of {@code Ser}, not null
       */
      @Override
      Object writeReplace() {
          return super.writeReplace();
      }
  
      /**
       * Defend against malicious streams.
       *
       * @param s the stream to read
       * @throws InvalidObjectException always
       */
      private void readObject(ObjectInputStream s) throws InvalidObjectException {
          throw new InvalidObjectException("Deserialization via serialization delegate");
      }
  }
  