/*
 * Copyright (C) 2012 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  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.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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.
 */

#include "third_party/blink/renderer/core/html/forms/date_time_edit_element.h"

#include "third_party/blink/renderer/core/css/style_change_reason.h"
#include "third_party/blink/renderer/core/dom/document.h"
#include "third_party/blink/renderer/core/dom/text.h"
#include "third_party/blink/renderer/core/events/mouse_event.h"
#include "third_party/blink/renderer/core/frame/use_counter_helper.h"
#include "third_party/blink/renderer/core/html/forms/date_time_field_elements.h"
#include "third_party/blink/renderer/core/html/forms/date_time_fields_state.h"
#include "third_party/blink/renderer/core/html/shadow/shadow_element_names.h"
#include "third_party/blink/renderer/core/html_names.h"
#include "third_party/blink/renderer/core/style/computed_style.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
#include "third_party/blink/renderer/platform/fonts/font_cache.h"
#include "third_party/blink/renderer/platform/heap/heap.h"
#include "third_party/blink/renderer/platform/instrumentation/use_counter.h"
#include "third_party/blink/renderer/platform/text/date_time_format.h"
#include "third_party/blink/renderer/platform/text/platform_locale.h"
#include "third_party/blink/renderer/platform/wtf/date_math.h"

namespace blink {

class DateTimeEditBuilder : private DateTimeFormat::TokenHandler {
 public:
  // The argument objects must be alive until this object dies.
  DateTimeEditBuilder(DateTimeEditElement&,
                      const DateTimeEditElement::LayoutParameters&,
                      const DateComponents&);

  bool Build(const String&);

 private:
  bool NeedMillisecondField() const;
  bool ShouldAMPMFieldDisabled() const;
  bool ShouldDayOfMonthFieldDisabled() const;
  bool ShouldHourFieldDisabled() const;
  bool ShouldMillisecondFieldDisabled() const;
  bool ShouldMinuteFieldDisabled() const;
  bool ShouldSecondFieldDisabled() const;
  bool ShouldYearFieldDisabled() const;
  inline const StepRange& GetStepRange() const {
    return parameters_.step_range;
  }
  DateTimeNumericFieldElement::Step CreateStep(double ms_per_field_unit,
                                               double ms_per_field_size) const;

  // DateTimeFormat::TokenHandler functions.
  void VisitField(DateTimeFormat::FieldType, int) final;
  void VisitLiteral(const String&) final;

  DateTimeEditElement& EditElement() const;

  DateTimeEditElement* edit_element_;
  const DateComponents date_value_;
  const DateTimeEditElement::LayoutParameters& parameters_;
  DateTimeNumericFieldElement::Range day_range_;
  DateTimeNumericFieldElement::Range hour23_range_;
  DateTimeNumericFieldElement::Range minute_range_;
  DateTimeNumericFieldElement::Range second_range_;
  DateTimeNumericFieldElement::Range millisecond_range_;
};

DateTimeEditBuilder::DateTimeEditBuilder(
    DateTimeEditElement& element,
    const DateTimeEditElement::LayoutParameters& layout_parameters,
    const DateComponents& date_value)
    : edit_element_(&element),
      date_value_(date_value),
      parameters_(layout_parameters),
      day_range_(1, 31),
      hour23_range_(0, 23),
      minute_range_(0, 59),
      second_range_(0, 59),
      millisecond_range_(0, 999) {
  if (date_value_.GetType() == DateComponents::kDate ||
      date_value_.GetType() == DateComponents::kDateTimeLocal) {
    if (parameters_.minimum.GetType() != DateComponents::kInvalid &&
        parameters_.maximum.GetType() != DateComponents::kInvalid &&
        parameters_.minimum.FullYear() == parameters_.maximum.FullYear() &&
        parameters_.minimum.Month() == parameters_.maximum.Month() &&
        parameters_.minimum.MonthDay() <= parameters_.maximum.MonthDay()) {
      day_range_.minimum = parameters_.minimum.MonthDay();
      day_range_.maximum = parameters_.maximum.MonthDay();
    }
  }

  if (date_value_.GetType() == DateComponents::kTime ||
      day_range_.IsSingleton()) {
    if (parameters_.minimum.GetType() != DateComponents::kInvalid &&
        parameters_.maximum.GetType() != DateComponents::kInvalid &&
        parameters_.minimum.Hour() <= parameters_.maximum.Hour()) {
      hour23_range_.minimum = parameters_.minimum.Hour();
      hour23_range_.maximum = parameters_.maximum.Hour();
    }
  }

  if (hour23_range_.IsSingleton() &&
      parameters_.minimum.Minute() <= parameters_.maximum.Minute()) {
    minute_range_.minimum = parameters_.minimum.Minute();
    minute_range_.maximum = parameters_.maximum.Minute();
  }
  if (minute_range_.IsSingleton() &&
      parameters_.minimum.Second() <= parameters_.maximum.Second()) {
    second_range_.minimum = parameters_.minimum.Second();
    second_range_.maximum = parameters_.maximum.Second();
  }
  if (second_range_.IsSingleton() &&
      parameters_.minimum.Millisecond() <= parameters_.maximum.Millisecond()) {
    millisecond_range_.minimum = parameters_.minimum.Millisecond();
    millisecond_range_.maximum = parameters_.maximum.Millisecond();
  }
}

bool DateTimeEditBuilder::Build(const String& format_string) {
  EditElement().ResetFields();

  // Mute UseCounter when constructing the DateTime object, to avoid counting
  // attributes on elements inside the user-agent shadow DOM.
  UseCounterMuteScope scope(EditElement());
  return DateTimeFormat::Parse(format_string, *this);
}

bool DateTimeEditBuilder::NeedMillisecondField() const {
  return date_value_.Millisecond() ||
         !GetStepRange()
              .Minimum()
              .Remainder(static_cast<int>(kMsPerSecond))
              .IsZero() ||
         !GetStepRange()
              .Step()
              .Remainder(static_cast<int>(kMsPerSecond))
              .IsZero();
}

void DateTimeEditBuilder::VisitField(DateTimeFormat::FieldType field_type,
                                     int count) {
  const int kCountForAbbreviatedMonth = 3;
  const int kCountForFullMonth = 4;
  const int kCountForNarrowMonth = 5;
  Document& document = EditElement().GetDocument();

  switch (field_type) {
    case DateTimeFormat::kFieldTypeDayOfMonth: {
      DateTimeFieldElement* field =
          MakeGarbageCollected<DateTimeDayFieldElement>(
              document, EditElement(), parameters_.placeholder_for_day,
              day_range_);
      EditElement().AddField(field);
      if (ShouldDayOfMonthFieldDisabled()) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }
      return;
    }

    case DateTimeFormat::kFieldTypeHour11: {
      DateTimeNumericFieldElement::Step step =
          CreateStep(kMsPerHour, kMsPerHour * 12);
      DateTimeFieldElement* field =
          MakeGarbageCollected<DateTimeHour11FieldElement>(
              document, EditElement(), hour23_range_, step);
      EditElement().AddField(field);
      if (ShouldHourFieldDisabled()) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }
      return;
    }

    case DateTimeFormat::kFieldTypeHour12: {
      DateTimeNumericFieldElement::Step step =
          CreateStep(kMsPerHour, kMsPerHour * 12);
      DateTimeFieldElement* field =
          MakeGarbageCollected<DateTimeHour12FieldElement>(
              document, EditElement(), hour23_range_, step);
      EditElement().AddField(field);
      if (ShouldHourFieldDisabled()) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }
      return;
    }

    case DateTimeFormat::kFieldTypeHour23: {
      DateTimeNumericFieldElement::Step step =
          CreateStep(kMsPerHour, kMsPerDay);
      DateTimeFieldElement* field =
          MakeGarbageCollected<DateTimeHour23FieldElement>(
              document, EditElement(), hour23_range_, step);
      EditElement().AddField(field);
      if (ShouldHourFieldDisabled()) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }
      return;
    }

    case DateTimeFormat::kFieldTypeHour24: {
      DateTimeNumericFieldElement::Step step =
          CreateStep(kMsPerHour, kMsPerDay);
      DateTimeFieldElement* field =
          MakeGarbageCollected<DateTimeHour24FieldElement>(
              document, EditElement(), hour23_range_, step);
      EditElement().AddField(field);
      if (ShouldHourFieldDisabled()) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }
      return;
    }

    case DateTimeFormat::kFieldTypeMinute: {
      DateTimeNumericFieldElement::Step step =
          CreateStep(kMsPerMinute, kMsPerHour);
      DateTimeNumericFieldElement* field =
          MakeGarbageCollected<DateTimeMinuteFieldElement>(
              document, EditElement(), minute_range_, step);
      EditElement().AddField(field);
      if (ShouldMinuteFieldDisabled()) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }
      return;
    }

    case DateTimeFormat::kFieldTypeMonth:  // Fallthrough.
    case DateTimeFormat::kFieldTypeMonthStandAlone: {
      int min_month = 0, max_month = 11;
      if (parameters_.minimum.GetType() != DateComponents::kInvalid &&
          parameters_.maximum.GetType() != DateComponents::kInvalid &&
          parameters_.minimum.FullYear() == parameters_.maximum.FullYear() &&
          parameters_.minimum.Month() <= parameters_.maximum.Month()) {
        min_month = parameters_.minimum.Month();
        max_month = parameters_.maximum.Month();
      }
      DateTimeFieldElement* field;
      switch (count) {
        case kCountForNarrowMonth:  // Fallthrough.
        case kCountForAbbreviatedMonth:
          field = MakeGarbageCollected<DateTimeSymbolicMonthFieldElement>(
              document, EditElement(),
              field_type == DateTimeFormat::kFieldTypeMonth
                  ? parameters_.locale.ShortMonthLabels()
                  : parameters_.locale.ShortStandAloneMonthLabels(),
              min_month, max_month);
          break;
        case kCountForFullMonth:
          field = MakeGarbageCollected<DateTimeSymbolicMonthFieldElement>(
              document, EditElement(),
              field_type == DateTimeFormat::kFieldTypeMonth
                  ? parameters_.locale.MonthLabels()
                  : parameters_.locale.StandAloneMonthLabels(),
              min_month, max_month);
          break;
        default:
          field = MakeGarbageCollected<DateTimeMonthFieldElement>(
              document, EditElement(), parameters_.placeholder_for_month,
              DateTimeNumericFieldElement::Range(min_month + 1, max_month + 1));
          break;
      }
      EditElement().AddField(field);
      if (min_month == max_month && min_month == date_value_.Month() &&
          date_value_.GetType() != DateComponents::kMonth) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }
      return;
    }

    case DateTimeFormat::kFieldTypePeriod: {
      DateTimeFieldElement* field =
          MakeGarbageCollected<DateTimeAMPMFieldElement>(
              document, EditElement(), parameters_.locale.TimeAMPMLabels());
      EditElement().AddField(field);
      if (ShouldAMPMFieldDisabled()) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }
      return;
    }

    case DateTimeFormat::kFieldTypeSecond: {
      DateTimeNumericFieldElement::Step step =
          CreateStep(kMsPerSecond, kMsPerMinute);
      DateTimeNumericFieldElement* field =
          MakeGarbageCollected<DateTimeSecondFieldElement>(
              document, EditElement(), second_range_, step);
      EditElement().AddField(field);
      if (ShouldSecondFieldDisabled()) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }

      if (NeedMillisecondField()) {
        VisitLiteral(parameters_.locale.LocalizedDecimalSeparator());
        VisitField(DateTimeFormat::kFieldTypeFractionalSecond, 3);
      }
      return;
    }

    case DateTimeFormat::kFieldTypeFractionalSecond: {
      DateTimeNumericFieldElement::Step step = CreateStep(1, kMsPerSecond);
      DateTimeNumericFieldElement* field =
          MakeGarbageCollected<DateTimeMillisecondFieldElement>(
              document, EditElement(), millisecond_range_, step);
      EditElement().AddField(field);
      if (ShouldMillisecondFieldDisabled()) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }
      return;
    }

    case DateTimeFormat::kFieldTypeWeekOfYear: {
      DateTimeNumericFieldElement::Range range(
          DateComponents::kMinimumWeekNumber,
          DateComponents::kMaximumWeekNumber);
      if (parameters_.minimum.GetType() != DateComponents::kInvalid &&
          parameters_.maximum.GetType() != DateComponents::kInvalid &&
          parameters_.minimum.FullYear() == parameters_.maximum.FullYear() &&
          parameters_.minimum.Week() <= parameters_.maximum.Week()) {
        range.minimum = parameters_.minimum.Week();
        range.maximum = parameters_.maximum.Week();
      }
      EditElement().AddField(MakeGarbageCollected<DateTimeWeekFieldElement>(
          document, EditElement(), range));
      return;
    }

    case DateTimeFormat::kFieldTypeYear: {
      DateTimeYearFieldElement::Parameters year_params;
      if (parameters_.minimum.GetType() == DateComponents::kInvalid) {
        year_params.minimum_year = DateComponents::MinimumYear();
        year_params.min_is_specified = false;
      } else {
        year_params.minimum_year = parameters_.minimum.FullYear();
        year_params.min_is_specified = true;
      }
      if (parameters_.maximum.GetType() == DateComponents::kInvalid) {
        year_params.maximum_year = DateComponents::MaximumYear();
        year_params.max_is_specified = false;
      } else {
        year_params.maximum_year = parameters_.maximum.FullYear();
        year_params.max_is_specified = true;
      }
      if (year_params.minimum_year > year_params.maximum_year) {
        std::swap(year_params.minimum_year, year_params.maximum_year);
        std::swap(year_params.min_is_specified, year_params.max_is_specified);
      }
      year_params.placeholder = parameters_.placeholder_for_year;
      DateTimeFieldElement* field =
          MakeGarbageCollected<DateTimeYearFieldElement>(
              document, EditElement(), year_params);
      EditElement().AddField(field);
      if (ShouldYearFieldDisabled()) {
        field->SetValueAsDate(date_value_);
        field->SetDisabled();
      }
      return;
    }

    default:
      return;
  }
}

bool DateTimeEditBuilder::ShouldAMPMFieldDisabled() const {
  return ShouldHourFieldDisabled() ||
         (hour23_range_.minimum < 12 && hour23_range_.maximum < 12 &&
          date_value_.Hour() < 12) ||
         (hour23_range_.minimum >= 12 && hour23_range_.maximum >= 12 &&
          date_value_.Hour() >= 12);
}

bool DateTimeEditBuilder::ShouldDayOfMonthFieldDisabled() const {
  return day_range_.IsSingleton() &&
         day_range_.minimum == date_value_.MonthDay() &&
         date_value_.GetType() != DateComponents::kDate;
}

bool DateTimeEditBuilder::ShouldHourFieldDisabled() const {
  if (hour23_range_.IsSingleton() &&
      hour23_range_.minimum == date_value_.Hour() &&
      !(ShouldMinuteFieldDisabled() && ShouldSecondFieldDisabled() &&
        ShouldMillisecondFieldDisabled()))
    return true;

  if (date_value_.GetType() == DateComponents::kTime)
    return false;
  DCHECK_EQ(date_value_.GetType(), DateComponents::kDateTimeLocal);

  if (ShouldDayOfMonthFieldDisabled()) {
    DCHECK_EQ(parameters_.minimum.FullYear(), parameters_.maximum.FullYear());
    DCHECK_EQ(parameters_.minimum.Month(), parameters_.maximum.Month());
    return false;
  }

  const Decimal decimal_ms_per_day(static_cast<int>(kMsPerDay));
  Decimal hour_part_of_minimum =
      (GetStepRange().StepBase().Abs().Remainder(decimal_ms_per_day) /
       static_cast<int>(kMsPerHour))
          .Floor();
  return hour_part_of_minimum == date_value_.Hour() &&
         GetStepRange().Step().Remainder(decimal_ms_per_day).IsZero();
}

bool DateTimeEditBuilder::ShouldMillisecondFieldDisabled() const {
  if (millisecond_range_.IsSingleton() &&
      millisecond_range_.minimum == date_value_.Millisecond())
    return true;

  const Decimal decimal_ms_per_second(static_cast<int>(kMsPerSecond));
  return GetStepRange().StepBase().Abs().Remainder(decimal_ms_per_second) ==
             date_value_.Millisecond() &&
         GetStepRange().Step().Remainder(decimal_ms_per_second).IsZero();
}

bool DateTimeEditBuilder::ShouldMinuteFieldDisabled() const {
  if (minute_range_.IsSingleton() &&
      minute_range_.minimum == date_value_.Minute())
    return true;

  const Decimal decimal_ms_per_hour(static_cast<int>(kMsPerHour));
  Decimal minute_part_of_minimum =
      (GetStepRange().StepBase().Abs().Remainder(decimal_ms_per_hour) /
       static_cast<int>(kMsPerMinute))
          .Floor();
  return minute_part_of_minimum == date_value_.Minute() &&
         GetStepRange().Step().Remainder(decimal_ms_per_hour).IsZero();
}

bool DateTimeEditBuilder::ShouldSecondFieldDisabled() const {
  if (second_range_.IsSingleton() &&
      second_range_.minimum == date_value_.Second())
    return true;

  const Decimal decimal_ms_per_minute(static_cast<int>(kMsPerMinute));
  Decimal second_part_of_minimum =
      (GetStepRange().StepBase().Abs().Remainder(decimal_ms_per_minute) /
       static_cast<int>(kMsPerSecond))
          .Floor();
  return second_part_of_minimum == date_value_.Second() &&
         GetStepRange().Step().Remainder(decimal_ms_per_minute).IsZero();
}

bool DateTimeEditBuilder::ShouldYearFieldDisabled() const {
  return parameters_.minimum.GetType() != DateComponents::kInvalid &&
         parameters_.maximum.GetType() != DateComponents::kInvalid &&
         parameters_.minimum.FullYear() == parameters_.maximum.FullYear() &&
         parameters_.minimum.FullYear() == date_value_.FullYear();
}

void DateTimeEditBuilder::VisitLiteral(const String& text) {
  DEFINE_STATIC_LOCAL(AtomicString, text_pseudo_id,
                      ("-webkit-datetime-edit-text"));
  DCHECK_GT(text.length(), 0u);
  auto* element =
      MakeGarbageCollected<HTMLDivElement>(EditElement().GetDocument());
  element->SetShadowPseudoId(text_pseudo_id);
  if (parameters_.locale.IsRTL() && text.length()) {
    WTF::unicode::CharDirection dir = WTF::unicode::Direction(text[0]);
    if (dir == WTF::unicode::kSegmentSeparator ||
        dir == WTF::unicode::kWhiteSpaceNeutral ||
        dir == WTF::unicode::kOtherNeutral)
      element->AppendChild(Text::Create(EditElement().GetDocument(),
                                        String(&kRightToLeftMarkCharacter, 1)));
  }
  element->AppendChild(Text::Create(EditElement().GetDocument(), text));
  EditElement().FieldsWrapperElement()->AppendChild(element);
}

DateTimeEditElement& DateTimeEditBuilder::EditElement() const {
  return *edit_element_;
}

DateTimeNumericFieldElement::Step DateTimeEditBuilder::CreateStep(
    double ms_per_field_unit,
    double ms_per_field_size) const {
  const Decimal ms_per_field_unit_decimal(static_cast<int>(ms_per_field_unit));
  const Decimal ms_per_field_size_decimal(static_cast<int>(ms_per_field_size));
  Decimal step_milliseconds = GetStepRange().Step();
  DCHECK(!ms_per_field_unit_decimal.IsZero());
  DCHECK(!ms_per_field_size_decimal.IsZero());
  DCHECK(!step_milliseconds.IsZero());

  DateTimeNumericFieldElement::Step step(1, 0);

  if (step_milliseconds.Remainder(ms_per_field_size_decimal).IsZero())
    step_milliseconds = ms_per_field_size_decimal;

  if (ms_per_field_size_decimal.Remainder(step_milliseconds).IsZero() &&
      step_milliseconds.Remainder(ms_per_field_unit_decimal).IsZero()) {
    step.step = static_cast<int>(
        (step_milliseconds / ms_per_field_unit_decimal).ToDouble());
    step.step_base = static_cast<int>(
        (GetStepRange().StepBase() / ms_per_field_unit_decimal)
            .Floor()
            .Remainder(ms_per_field_size_decimal / ms_per_field_unit_decimal)
            .ToDouble());
  }
  return step;
}

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

DateTimeEditElement::EditControlOwner::~EditControlOwner() = default;

DateTimeEditElement::DateTimeEditElement(Document& document,
                                         EditControlOwner& edit_control_owner)
    : HTMLDivElement(document), edit_control_owner_(&edit_control_owner) {
  SetHasCustomStyleCallbacks();
  SetShadowPseudoId(AtomicString("-webkit-datetime-edit"));
  setAttribute(html_names::kIdAttr, shadow_element_names::kIdDateTimeEdit);
}

DateTimeEditElement::~DateTimeEditElement() = default;

void DateTimeEditElement::Trace(Visitor* visitor) const {
  visitor->Trace(fields_);
  visitor->Trace(edit_control_owner_);
  HTMLDivElement::Trace(visitor);
}

inline Element* DateTimeEditElement::FieldsWrapperElement() const {
  CHECK(!firstChild() || IsA<Element>(firstChild()));
  return To<Element>(firstChild());
}

void DateTimeEditElement::AddField(DateTimeFieldElement* field) {
  if (fields_.size() >= kMaximumNumberOfFields)
    return;
  fields_.push_back(field);
  FieldsWrapperElement()->AppendChild(field);
}

bool DateTimeEditElement::AnyEditableFieldsHaveValues() const {
  for (const auto& field : fields_) {
    if (!field->IsDisabled() && field->HasValue())
      return true;
  }
  return false;
}

void DateTimeEditElement::BlurByOwner() {
  if (DateTimeFieldElement* field = FocusedField())
    field->blur();
}

scoped_refptr<ComputedStyle> DateTimeEditElement::CustomStyleForLayoutObject(
    const StyleRecalcContext& style_recalc_context) {
  // TODO(crbug.com/1181868): This is a kind of layout. We might want to
  // introduce new LayoutObject.
  scoped_refptr<ComputedStyle> style =
      OriginalStyleForLayoutObject(style_recalc_context);
  float width = 0;
  for (Node* child = FieldsWrapperElement()->firstChild(); child;
       child = child->nextSibling()) {
    auto* child_element = DynamicTo<Element>(child);
    if (!child_element)
      continue;
    if (child_element->IsDateTimeFieldElement()) {
      // We need to pass the ComputedStyle of this element because child
      // elements can't resolve inherited style at this timing.
      width += static_cast<DateTimeFieldElement*>(child_element)
                   ->MaximumWidth(*style);
    } else {
      // ::-webkit-datetime-edit-text case. It has no
      // border/padding/margin in html.css.
      width += DateTimeFieldElement::ComputeTextWidth(
          *style, child_element->textContent());
    }
  }
  style->SetWidth(Length::Fixed(ceilf(width)));
  style->SetCustomStyleCallbackDependsOnFont();
  return style;
}

void DateTimeEditElement::DidBlurFromField(mojom::blink::FocusType focus_type) {
  if (edit_control_owner_)
    edit_control_owner_->DidBlurFromControl(focus_type);
}

void DateTimeEditElement::DidFocusOnField(mojom::blink::FocusType focus_type) {
  if (edit_control_owner_)
    edit_control_owner_->DidFocusOnControl(focus_type);
}

void DateTimeEditElement::DisabledStateChanged() {
  UpdateUIState();
}

DateTimeFieldElement* DateTimeEditElement::FieldAt(
    wtf_size_t field_index) const {
  return field_index < fields_.size() ? fields_[field_index].Get() : nullptr;
}

wtf_size_t DateTimeEditElement::FieldIndexOf(
    const DateTimeFieldElement& field) const {
  for (wtf_size_t field_index = 0; field_index < fields_.size();
       ++field_index) {
    if (fields_[field_index] == &field)
      return field_index;
  }
  return kInvalidFieldIndex;
}

void DateTimeEditElement::FocusIfNoFocus() {
  if (FocusedFieldIndex() != kInvalidFieldIndex)
    return;
  FocusOnNextFocusableField(0);
}

void DateTimeEditElement::FocusByOwner(Element* old_focused_element) {
  if (old_focused_element && old_focused_element->IsDateTimeFieldElement()) {
    DateTimeFieldElement* old_focused_field =
        static_cast<DateTimeFieldElement*>(old_focused_element);
    wtf_size_t index = FieldIndexOf(*old_focused_field);
    GetDocument().UpdateStyleAndLayoutTreeForNode(old_focused_field);
    if (index != kInvalidFieldIndex && old_focused_field->IsFocusable()) {
      old_focused_field->focus();
      return;
    }
  }
  FocusOnNextFocusableField(0);
}

DateTimeFieldElement* DateTimeEditElement::FocusedField() const {
  return FieldAt(FocusedFieldIndex());
}

wtf_size_t DateTimeEditElement::FocusedFieldIndex() const {
  Element* const focused_field_element = GetDocument().FocusedElement();
  for (wtf_size_t field_index = 0; field_index < fields_.size();
       ++field_index) {
    if (fields_[field_index] == focused_field_element)
      return field_index;
  }
  return kInvalidFieldIndex;
}

void DateTimeEditElement::FieldValueChanged() {
  if (edit_control_owner_)
    edit_control_owner_->EditControlValueChanged();
}

bool DateTimeEditElement::FocusOnNextFocusableField(wtf_size_t start_index) {
  GetDocument().UpdateStyleAndLayoutTree();
  for (wtf_size_t field_index = start_index; field_index < fields_.size();
       ++field_index) {
    if (fields_[field_index]->IsFocusable()) {
      fields_[field_index]->focus();
      return true;
    }
  }
  return false;
}

bool DateTimeEditElement::FocusOnNextField(const DateTimeFieldElement& field) {
  const wtf_size_t start_field_index = FieldIndexOf(field);
  if (start_field_index == kInvalidFieldIndex)
    return false;
  return FocusOnNextFocusableField(start_field_index + 1);
}

bool DateTimeEditElement::FocusOnPreviousField(
    const DateTimeFieldElement& field) {
  const wtf_size_t start_field_index = FieldIndexOf(field);
  if (start_field_index == kInvalidFieldIndex)
    return false;
  GetDocument().UpdateStyleAndLayoutTree();
  wtf_size_t field_index = start_field_index;
  while (field_index > 0) {
    --field_index;
    if (fields_[field_index]->IsFocusable()) {
      fields_[field_index]->focus();
      return true;
    }
  }
  return false;
}

void DateTimeEditElement::HandleAmPmRollover(
    DateTimeFieldElement::FieldRolloverType rollover_type) {
  auto* ampm_field = GetField(DateTimeField::kAMPM);
  if (!ampm_field)
    return;
  DateTimeFieldsState date_time_fields_state = ValueAsDateTimeFieldsState();
  ampm_field->PopulateDateTimeFieldsState(date_time_fields_state);
  bool was_am =
      (date_time_fields_state.Ampm() == DateTimeFieldsState::kAMPMValueAM);
  date_time_fields_state.SetAMPM(DateTimeFieldsState::kAMPMValuePM);
  if (rollover_type != DateTimeFieldElement::FieldRolloverType::kToPm &&
      !was_am)
    date_time_fields_state.SetAMPM(DateTimeFieldsState::kAMPMValueAM);
  ampm_field->SetValueAsDateTimeFieldsState(date_time_fields_state);
  // No need to call EditControlValueChanged since change that triggered
  // rollover will do so.
}

bool DateTimeEditElement::IsDateTimeEditElement() const {
  return true;
}

bool DateTimeEditElement::IsDisabled() const {
  return edit_control_owner_ &&
         edit_control_owner_->IsEditControlOwnerDisabled();
}

bool DateTimeEditElement::IsFieldOwnerDisabled() const {
  return IsDisabled();
}

bool DateTimeEditElement::IsFieldOwnerReadOnly() const {
  return IsReadOnly();
}

bool DateTimeEditElement::IsReadOnly() const {
  return edit_control_owner_ &&
         edit_control_owner_->IsEditControlOwnerReadOnly();
}

void DateTimeEditElement::GetLayout(const LayoutParameters& layout_parameters,
                                    const DateComponents& date_value) {
  // TODO(tkent): We assume this function never dispatches events. However this
  // can dispatch 'blur' event in Node::removeChild().

  DEFINE_STATIC_LOCAL(AtomicString, fields_wrapper_pseudo_id,
                      ("-webkit-datetime-edit-fields-wrapper"));
  if (!HasChildren()) {
    auto* element = MakeGarbageCollected<HTMLDivElement>(GetDocument());
    element->SetShadowPseudoId(fields_wrapper_pseudo_id);
    AppendChild(element);
  }
  Element* fields_wrapper = FieldsWrapperElement();

  wtf_size_t focused_field_index = FocusedFieldIndex();
  DateTimeFieldElement* const focused_field = FieldAt(focused_field_index);
  const AtomicString focused_field_id =
      focused_field ? focused_field->ShadowPseudoId() : g_null_atom;

  DateTimeEditBuilder builder(*this, layout_parameters, date_value);
  Node* last_child_to_be_removed = fields_wrapper->lastChild();
  if (!builder.Build(layout_parameters.date_time_format) || fields_.IsEmpty()) {
    last_child_to_be_removed = fields_wrapper->lastChild();
    builder.Build(layout_parameters.fallback_date_time_format);
  }

  if (focused_field_index != kInvalidFieldIndex) {
    for (wtf_size_t field_index = 0; field_index < fields_.size();
         ++field_index) {
      if (fields_[field_index]->ShadowPseudoId() == focused_field_id) {
        focused_field_index = field_index;
        break;
      }
    }
    if (DateTimeFieldElement* field =
            FieldAt(std::min(focused_field_index, fields_.size() - 1)))
      field->focus();
  }

  if (last_child_to_be_removed) {
    for (Node* child_node = fields_wrapper->firstChild(); child_node;
         child_node = fields_wrapper->firstChild()) {
      fields_wrapper->RemoveChild(child_node);
      if (child_node == last_child_to_be_removed)
        break;
    }
    SetNeedsStyleRecalc(
        kSubtreeStyleChange,
        StyleChangeReasonForTracing::Create(style_change_reason::kControl));
  }
}

AtomicString DateTimeEditElement::LocaleIdentifier() const {
  return edit_control_owner_ ? edit_control_owner_->LocaleIdentifier()
                             : g_null_atom;
}

void DateTimeEditElement::FieldDidChangeValueByKeyboard() {
  if (edit_control_owner_)
    edit_control_owner_->EditControlDidChangeValueByKeyboard();
}

void DateTimeEditElement::ReadOnlyStateChanged() {
  UpdateUIState();
}

void DateTimeEditElement::ResetFields() {
  for (const auto& field : fields_)
    field->RemoveEventHandler();
  fields_.Shrink(0);
}

void DateTimeEditElement::DefaultEventHandler(Event& event) {
  // In case of control owner forward event to control, e.g. DOM
  // dispatchEvent method.
  if (DateTimeFieldElement* field = FocusedField()) {
    field->DefaultEventHandler(event);
    if (event.DefaultHandled())
      return;
  }

  HTMLDivElement::DefaultEventHandler(event);
}

void DateTimeEditElement::SetValueAsDate(
    const LayoutParameters& layout_parameters,
    const DateComponents& date) {
  GetLayout(layout_parameters, date);
  for (const auto& field : fields_)
    field->SetValueAsDate(date);
}

void DateTimeEditElement::SetValueAsDateTimeFieldsState(
    const DateTimeFieldsState& date_time_fields_state) {
  for (const auto& field : fields_)
    field->SetValueAsDateTimeFieldsState(date_time_fields_state);
}

void DateTimeEditElement::SetEmptyValue(
    const LayoutParameters& layout_parameters,
    const DateComponents& date_for_read_only_field) {
  GetLayout(layout_parameters, date_for_read_only_field);
  for (const auto& field : fields_)
    field->SetEmptyValue(DateTimeFieldElement::kDispatchNoEvent);
}

DateTimeFieldElement* DateTimeEditElement::GetField(DateTimeField type) const {
  auto* it = std::find_if(
      fields_.begin(), fields_.end(),
      [&type](const auto& field) { return field->Type() == type; });
  if (it == fields_.end())
    return nullptr;
  return *it;
}

bool DateTimeEditElement::HasField(DateTimeField type) const {
  for (const auto& field : fields_) {
    if (field->Type() == type)
      return true;
  }

  return false;
}

bool DateTimeEditElement::IsFirstFieldAMPM() const {
  const auto* first_field = FieldAt(0);
  return first_field && first_field->Type() == DateTimeField::kAMPM;
}

bool DateTimeEditElement::HasFocusedField() {
  return FocusedFieldIndex() != kInvalidFieldIndex;
}

void PopulateOnlyYearMonthDay(const DateComponents& date,
                              DateTimeFieldsState& date_time_fields_state) {
  date_time_fields_state.SetYear(date.FullYear());
  date_time_fields_state.SetMonth(date.Month() + 1);
  date_time_fields_state.SetDayOfMonth(date.MonthDay());
}

void DateTimeEditElement::SetOnlyYearMonthDay(const DateComponents& date) {
  DCHECK_EQ(date.GetType(), DateComponents::kDate);

  if (!edit_control_owner_)
    return;

  DateTimeFieldsState date_time_fields_state = ValueAsDateTimeFieldsState();
  PopulateOnlyYearMonthDay(date, date_time_fields_state);
  SetValueAsDateTimeFieldsState(date_time_fields_state);
  edit_control_owner_->EditControlValueChanged();
}

void PopulateOnlyTime(const DateComponents& date,
                      DateTimeFieldsState& date_time_fields_state) {
  date_time_fields_state.SetHour(date.Hour() % 12 ? date.Hour() % 12 : 12);
  date_time_fields_state.SetMinute(date.Minute());
  date_time_fields_state.SetSecond(date.Second());
  date_time_fields_state.SetMillisecond(date.Millisecond());
  date_time_fields_state.SetAMPM(date.Hour() >= 12
                                     ? DateTimeFieldsState::kAMPMValuePM
                                     : DateTimeFieldsState::kAMPMValueAM);
}

void DateTimeEditElement::SetOnlyTime(const DateComponents& date) {
  DCHECK_EQ(date.GetType(), DateComponents::kTime);

  if (!edit_control_owner_)
    return;

  DateTimeFieldsState date_time_fields_state = ValueAsDateTimeFieldsState();
  PopulateOnlyTime(date, date_time_fields_state);
  SetValueAsDateTimeFieldsState(date_time_fields_state);
  edit_control_owner_->EditControlValueChanged();
}

void PopulateDateTimeLocal(const DateComponents& date,
                           DateTimeFieldsState& date_time_fields_state) {
  PopulateOnlyYearMonthDay(date, date_time_fields_state);
  PopulateOnlyTime(date, date_time_fields_state);
}

void DateTimeEditElement::SetDateTimeLocal(const DateComponents& date) {
  DCHECK_EQ(date.GetType(), DateComponents::kDateTimeLocal);

  if (!edit_control_owner_)
    return;

  DateTimeFieldsState date_time_fields_state = ValueAsDateTimeFieldsState();
  PopulateDateTimeLocal(date, date_time_fields_state);
  SetValueAsDateTimeFieldsState(date_time_fields_state);
  edit_control_owner_->EditControlValueChanged();
}

void DateTimeEditElement::StepDown() {
  if (DateTimeFieldElement* const field = FocusedField())
    field->StepDown();
}

void DateTimeEditElement::StepUp() {
  if (DateTimeFieldElement* const field = FocusedField())
    field->StepUp();
}

void DateTimeEditElement::UpdateUIState() {
  if (IsDisabled()) {
    if (DateTimeFieldElement* field = FocusedField())
      field->blur();
  }
}

String DateTimeEditElement::Value() const {
  if (!edit_control_owner_)
    return g_empty_string;
  return edit_control_owner_->FormatDateTimeFieldsState(
      ValueAsDateTimeFieldsState());
}

DateTimeFieldsState DateTimeEditElement::ValueAsDateTimeFieldsState() const {
  DateTimeFieldsState date_time_fields_state;
  for (const auto& field : fields_)
    field->PopulateDateTimeFieldsState(date_time_fields_state);
  return date_time_fields_state;
}

}  // namespace blink