/*

 * Copyright (c) 2012, 2013, 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.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Copyright (c) 2008-2013, 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.format;

import static java.time.temporal.ChronoField.AMPM_OF_DAY;

import static java.time.temporal.ChronoField.CLOCK_HOUR_OF_AMPM;

import static java.time.temporal.ChronoField.CLOCK_HOUR_OF_DAY;

import static java.time.temporal.ChronoField.HOUR_OF_AMPM;

import static java.time.temporal.ChronoField.HOUR_OF_DAY;

import static java.time.temporal.ChronoField.MICRO_OF_DAY;

import static java.time.temporal.ChronoField.MICRO_OF_SECOND;

import static java.time.temporal.ChronoField.MILLI_OF_DAY;

import static java.time.temporal.ChronoField.MILLI_OF_SECOND;

import static java.time.temporal.ChronoField.MINUTE_OF_DAY;

import static java.time.temporal.ChronoField.MINUTE_OF_HOUR;

import static java.time.temporal.ChronoField.NANO_OF_DAY;

import static java.time.temporal.ChronoField.NANO_OF_SECOND;

import static java.time.temporal.ChronoField.SECOND_OF_DAY;

import static java.time.temporal.ChronoField.SECOND_OF_MINUTE;

import java.time.DateTimeException;

import java.time.LocalDate;

import java.time.LocalTime;

import java.time.ZoneId;

import java.time.chrono.ChronoLocalDate;

import java.time.chrono.Chronology;

import java.time.temporal.ChronoField;

import java.time.temporal.TemporalAccessor;

import java.time.temporal.TemporalField;

import java.time.temporal.TemporalQuery;

import java.time.temporal.UnsupportedTemporalTypeException;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Objects;

import java.util.Set;

/**

 * A store of parsed data.

 * <p>

 * This class is used during parsing to collect the data. Part of the parsing process

 * involves handling optional blocks and multiple copies of the data get created to

 * support the necessary backtracking.

 * <p>

 * Once parsing is completed, this class can be used as the resultant {@code TemporalAccessor}.

 * In most cases, it is only exposed once the fields have been resolved.

 *

 * This class is a mutable context intended for use from a single thread.

 * Usage of the class is thread-safe within standard parsing as a new instance of this class

 * is automatically created for each parse and parsing is single-threaded

 *

 * @since 1.8

 */

final class Parsed implements TemporalAccessor {

    // some fields are accessed using package scope from DateTimeParseContext

    /**

     * The parsed fields.

     */

    final Map<TemporalField, Long> fieldValues = new HashMap<>();

    /**

     * The parsed zone.

     */

    ZoneId zone;

    /**

     * The parsed chronology.

     */

    Chronology chrono;

    /**

     * The effective chronology.

     */

    Chronology effectiveChrono;

    /**

     * The resolver style to use.

     */

    private ResolverStyle resolverStyle;

    /**

     * The resolved date.

     */

    private ChronoLocalDate<?> date;

    /**

     * The resolved time.

     */

    private LocalTime time;

    /**

     * Creates an instance.

     */

    Parsed() {

    }

    /**

     * Creates a copy.

     */

    Parsed copy() {

        // only copy fields used in parsing stage

        Parsed cloned = new Parsed();

        cloned.fieldValues.putAll(this.fieldValues);

        cloned.zone = this.zone;

        cloned.chrono = this.chrono;

        return cloned;

    }

    //-----------------------------------------------------------------------

    @Override

    public boolean isSupported(TemporalField field) {

        if (fieldValues.containsKey(field) ||

                (date != null && date.isSupported(field)) ||

                (time != null && time.isSupported(field))) {

            return true;

        }

        return field != null && (field instanceof ChronoField == false) && field.isSupportedBy(this);

    }

    @Override

    public long getLong(TemporalField field) {

        Objects.requireNonNull(field, "field");

        Long value = fieldValues.get(field);

        if (value != null) {

            return value;

        }

        if (date != null && date.isSupported(field)) {

            return date.getLong(field);

        }

        if (time != null && time.isSupported(field)) {

            return time.getLong(field);

        }

        if (field instanceof ChronoField) {

            throw new UnsupportedTemporalTypeException("Unsupported field: " + field.getName());

        }

        return field.getFrom(this);

    }

    @SuppressWarnings("unchecked")

    @Override

    public <R> R query(TemporalQuery<R> query) {

        if (query == TemporalQuery.zoneId()) {

            return (R) zone;

        } else if (query == TemporalQuery.chronology()) {

            return (R) chrono;

        } else if (query == TemporalQuery.localDate()) {

            return (R) (date != null ? LocalDate.from(date) : null);

        } else if (query == TemporalQuery.localTime()) {

            return (R) time;

        } else if (query == TemporalQuery.zone() || query == TemporalQuery.offset()) {

            return query.queryFrom(this);

        } else if (query == TemporalQuery.precision()) {

            return null;  // not a complete date/time

        }

        // inline TemporalAccessor.super.query(query) as an optimization

        // non-JDK classes are not permitted to make this optimization

        return query.queryFrom(this);

    }

    //-----------------------------------------------------------------------

    /**

     * Resolves the fields in this context.

     *

     * @param resolverStyle  the resolver style, not null

     * @param resolverFields  the fields to use for resolving, null for all fields

     * @return this, for method chaining

     * @throws DateTimeException if resolving one field results in a value for

     *  another field that is in conflict

     */

    TemporalAccessor resolve(ResolverStyle resolverStyle, Set<TemporalField> resolverFields) {

        if (resolverFields != null) {

            fieldValues.keySet().retainAll(resolverFields);

        }

        this.resolverStyle = resolverStyle;

        chrono = effectiveChrono;

        resolveFields();

        resolveTimeLenient();

        crossCheck();

        return this;

    }

    //-----------------------------------------------------------------------

    private void resolveFields() {

        // resolve ChronoField

        resolveDateFields();

        resolveTimeFields();

        // if any other fields, handle them

        // any lenient date resolution should return epoch-day

        if (fieldValues.size() > 0) {

            boolean changed = false;

            outer:

            while (true) {

                for (Map.Entry<TemporalField, Long> entry : fieldValues.entrySet()) {

                    TemporalField targetField = entry.getKey();

                    Map<TemporalField, Long> changes = targetField.resolve(this, entry.getValue(), resolverStyle);

                    if (changes != null) {

                        changed = true;

                        resolveFieldsMakeChanges(targetField, changes);

                        fieldValues.remove(targetField);  // helps avoid infinite loops

                        continue outer;  // have to restart to avoid concurrent modification

                    }

                }

                break;

            }

            // if something changed then have to redo ChronoField resolve

            if (changed) {

                resolveDateFields();

                resolveTimeFields();

            }

        }

    }

    private void resolveFieldsMakeChanges(TemporalField targetField, Map<TemporalField, Long> changes) {

        for (Map.Entry<TemporalField, Long> change : changes.entrySet()) {

            TemporalField changeField = change.getKey();

            Long changeValue = change.getValue();

            Objects.requireNonNull(changeField, "changeField");

            if (changeValue != null) {

                updateCheckConflict(targetField, changeField, changeValue);

            } else {

                fieldValues.remove(changeField);

            }

        }

    }

    private void updateCheckConflict(TemporalField targetField, TemporalField changeField, Long changeValue) {

        Long old = fieldValues.put(changeField, changeValue);

        if (old != null && old.longValue() != changeValue.longValue()) {

            throw new DateTimeException("Conflict found: " + changeField + " " + old +

                    " differs from " + changeField + " " + changeValue +

                    " while resolving  " + targetField);

        }

    }

    //-----------------------------------------------------------------------

    private void resolveDateFields() {

        updateCheckConflict(chrono.resolveDate(fieldValues, resolverStyle));

    }

    private void updateCheckConflict(ChronoLocalDate<?> cld) {

        if (date != null) {

            if (cld != null && date.equals(cld) == false) {

                throw new DateTimeException("Conflict found: Fields resolved to two different dates: " + date + " " + cld);

            }

        } else {

            date = cld;

        }

    }

    //-----------------------------------------------------------------------

    private void resolveTimeFields() {

        // simplify fields

        if (fieldValues.containsKey(CLOCK_HOUR_OF_DAY)) {

            long ch = fieldValues.remove(CLOCK_HOUR_OF_DAY);

            updateCheckConflict(CLOCK_HOUR_OF_DAY, HOUR_OF_DAY, ch == 24 ? 0 : ch);

        }

        if (fieldValues.containsKey(CLOCK_HOUR_OF_AMPM)) {

            long ch = fieldValues.remove(CLOCK_HOUR_OF_AMPM);

            updateCheckConflict(CLOCK_HOUR_OF_AMPM, HOUR_OF_AMPM, ch == 12 ? 0 : ch);

        }

        if (fieldValues.containsKey(AMPM_OF_DAY) && fieldValues.containsKey(HOUR_OF_AMPM)) {

            long ap = fieldValues.remove(AMPM_OF_DAY);

            long hap = fieldValues.remove(HOUR_OF_AMPM);

        }

        if (fieldValues.containsKey(MICRO_OF_DAY)) {

            long cod = fieldValues.remove(MICRO_OF_DAY);

            updateCheckConflict(MICRO_OF_DAY, SECOND_OF_DAY, cod / 1_000_000L);

            updateCheckConflict(MICRO_OF_DAY, MICRO_OF_SECOND, cod % 1_000_000L);

        }

        if (fieldValues.containsKey(MILLI_OF_DAY)) {

            long lod = fieldValues.remove(MILLI_OF_DAY);

            updateCheckConflict(MILLI_OF_DAY, SECOND_OF_DAY, lod / 1_000);

            updateCheckConflict(MILLI_OF_DAY, MILLI_OF_SECOND, lod % 1_000);

        }

        if (fieldValues.containsKey(SECOND_OF_DAY)) {

            long sod = fieldValues.remove(SECOND_OF_DAY);

            updateCheckConflict(SECOND_OF_DAY, HOUR_OF_DAY, sod / 3600);

            updateCheckConflict(SECOND_OF_DAY, MINUTE_OF_HOUR, (sod / 60) % 60);

            updateCheckConflict(SECOND_OF_DAY, SECOND_OF_MINUTE, sod % 60);

        }

        if (fieldValues.containsKey(MINUTE_OF_DAY)) {

            long mod = fieldValues.remove(MINUTE_OF_DAY);

            updateCheckConflict(MINUTE_OF_DAY, HOUR_OF_DAY, mod / 60);

            updateCheckConflict(MINUTE_OF_DAY, MINUTE_OF_HOUR, mod % 60);

        }

        // combine partial second fields strictly, leaving lenient expansion to later

        if (fieldValues.containsKey(NANO_OF_SECOND)) {

            long nos = fieldValues.get(NANO_OF_SECOND);

            if (fieldValues.containsKey(MICRO_OF_SECOND)) {

                long cos = fieldValues.remove(MICRO_OF_SECOND);

                nos = cos * 1000 + (nos % 1000);

                updateCheckConflict(MICRO_OF_SECOND, NANO_OF_SECOND, nos);

            }

            if (fieldValues.containsKey(MILLI_OF_SECOND)) {

                long los = fieldValues.remove(MILLI_OF_SECOND);

                updateCheckConflict(MILLI_OF_SECOND, NANO_OF_SECOND, los * 1_000_000L + (nos % 1_000_000L));

            }

        }

        if (fieldValues.containsKey(HOUR_OF_DAY) && fieldValues.containsKey(MINUTE_OF_HOUR) &&

                fieldValues.containsKey(SECOND_OF_MINUTE) && fieldValues.containsKey(NANO_OF_SECOND)) {

        }

    }

    private void resolveTimeLenient() {

        // leniently create a time from incomplete information

        // done after everything else as it creates information from nothing

        // which would break updateCheckConflict(field)

        if (time == null) {

            if (fieldValues.containsKey(MILLI_OF_SECOND)) {

                long los = fieldValues.remove(MILLI_OF_SECOND);

                if (fieldValues.containsKey(MICRO_OF_SECOND)) {

                    // merge milli-of-second and micro-of-second for better error message

                    long cos = los * 1_000 + (fieldValues.get(MICRO_OF_SECOND) % 1_000);

                    updateCheckConflict(MILLI_OF_SECOND, MICRO_OF_SECOND, cos);

                    fieldValues.remove(MICRO_OF_SECOND);

                    fieldValues.put(NANO_OF_SECOND, cos * 1_000L);

                } else {

                    // convert milli-of-second to nano-of-second

                    fieldValues.put(NANO_OF_SECOND, los * 1_000_000L);

                }

            } else if (fieldValues.containsKey(MICRO_OF_SECOND)) {

                // convert micro-of-second to nano-of-second

                long cos = fieldValues.remove(MICRO_OF_SECOND);

                fieldValues.put(NANO_OF_SECOND, cos * 1_000L);

            }

                if ((moh == null && (som != null || nos != null)) ||

                        (moh != null && som == null && nos != null)) {

                    return;

                }

        }

    }