// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "core/layout/ng/ng_constraint_space_builder.h"

#include "core/layout/ng/ng_length_utils.h"

namespace blink {

NGConstraintSpaceBuilder::NGConstraintSpaceBuilder(
    const NGConstraintSpace* parent_space)
    : available_size_(parent_space->AvailableSize()),
      percentage_resolution_size_(parent_space->PercentageResolutionSize()),
      initial_containing_block_size_(
          parent_space->InitialContainingBlockSize()),
      fragmentainer_space_available_(NGSizeIndefinite),
      parent_writing_mode_(parent_space->WritingMode()),
      is_fixed_size_inline_(false),
      is_fixed_size_block_(false),
      is_shrink_to_fit_(false),
      is_inline_direction_triggers_scrollbar_(false),
      is_block_direction_triggers_scrollbar_(false),
      fragmentation_type_(parent_space->BlockFragmentationType()),
      is_new_fc_(parent_space->IsNewFormattingContext()),
      text_direction_(static_cast<unsigned>(parent_space->Direction())),
      bfc_offset_(parent_space->bfc_offset_),
      exclusions_(parent_space->Exclusions()) {}

NGConstraintSpaceBuilder::NGConstraintSpaceBuilder(NGWritingMode writing_mode)
    : initial_containing_block_size_{NGSizeIndefinite, NGSizeIndefinite},
      fragmentainer_space_available_(NGSizeIndefinite),
      parent_writing_mode_(writing_mode),
      is_fixed_size_inline_(false),
      is_fixed_size_block_(false),
      is_shrink_to_fit_(false),
      is_inline_direction_triggers_scrollbar_(false),
      is_block_direction_triggers_scrollbar_(false),
      fragmentation_type_(kFragmentNone),
      is_new_fc_(false),
      text_direction_(static_cast<unsigned>(TextDirection::kLtr)),
      exclusions_(new NGExclusions()) {}

NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetAvailableSize(
    NGLogicalSize available_size) {
  available_size_ = available_size;
  return *this;
}

NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetPercentageResolutionSize(
    NGLogicalSize percentage_resolution_size) {
  percentage_resolution_size_ = percentage_resolution_size;
  return *this;
}

NGConstraintSpaceBuilder&
NGConstraintSpaceBuilder::SetInitialContainingBlockSize(NGPhysicalSize size) {
  initial_containing_block_size_ = size;
  return *this;
}

NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetTextDirection(
    TextDirection text_direction) {
  text_direction_ = static_cast<unsigned>(text_direction);
  return *this;
}

NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetMarginStrut(
    const NGMarginStrut& margin_strut) {
  margin_strut_ = margin_strut;
  return *this;
}

NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetIsFixedSizeInline(
    bool is_fixed_size_inline) {
  is_fixed_size_inline_ = is_fixed_size_inline;
  return *this;
}

NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetIsFixedSizeBlock(
    bool is_fixed_size_block) {
  is_fixed_size_block_ = is_fixed_size_block;
  return *this;
}

NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetIsShrinkToFit(
    bool shrink_to_fit) {
  is_shrink_to_fit_ = shrink_to_fit;
  return *this;
}

NGConstraintSpaceBuilder&
NGConstraintSpaceBuilder::SetIsInlineDirectionTriggersScrollbar(
    bool is_inline_direction_triggers_scrollbar) {
  is_inline_direction_triggers_scrollbar_ =
      is_inline_direction_triggers_scrollbar;
  return *this;
}

NGConstraintSpaceBuilder&
NGConstraintSpaceBuilder::SetIsBlockDirectionTriggersScrollbar(
    bool is_block_direction_triggers_scrollbar) {
  is_block_direction_triggers_scrollbar_ =
      is_block_direction_triggers_scrollbar;
  return *this;
}

NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetFragmentationType(
    NGFragmentationType fragmentation_type) {
  fragmentation_type_ = fragmentation_type;
  return *this;
}

NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetIsNewFormattingContext(
    bool is_new_fc) {
  is_new_fc_ = is_new_fc;
  return *this;
}

NGConstraintSpace* NGConstraintSpaceBuilder::ToConstraintSpace(
    NGWritingMode out_writing_mode) {
  // Whether the child and the containing block are parallel to each other.
  // Example: vertical-rl and vertical-lr
  bool is_in_parallel_flow = (parent_writing_mode_ == kHorizontalTopBottom) ==
                             (out_writing_mode == kHorizontalTopBottom);

  NGLogicalSize available_size = available_size_;
  NGLogicalSize percentage_resolution_size = percentage_resolution_size_;
  if (!is_in_parallel_flow) {
    std::swap(available_size.inline_size, available_size.block_size);
    std::swap(percentage_resolution_size.inline_size,
              percentage_resolution_size.block_size);
  }

  // If inline size is indefinite, use size of initial containing block.
  // https://www.w3.org/TR/css-writing-modes-3/#orthogonal-auto
  if (available_size.inline_size == NGSizeIndefinite) {
    DCHECK(!is_in_parallel_flow);
    if (out_writing_mode == kHorizontalTopBottom) {
      available_size.inline_size = initial_containing_block_size_.width;
    } else {
      available_size.inline_size = initial_containing_block_size_.height;
    }
  }
  if (percentage_resolution_size.inline_size == NGSizeIndefinite) {
    DCHECK(!is_in_parallel_flow);
    if (out_writing_mode == kHorizontalTopBottom) {
      percentage_resolution_size.inline_size =
          initial_containing_block_size_.width;
    } else {
      percentage_resolution_size.inline_size =
          initial_containing_block_size_.height;
    }
  }

  // Exclusions do not pass the formatting context boundary.
  std::shared_ptr<NGExclusions> exclusions(
      is_new_fc_ ? std::make_shared<NGExclusions>() : exclusions_);
  NGLogicalOffset bfc_offset = is_new_fc_ ? NGLogicalOffset() : bfc_offset_;
  NGMarginStrut margin_strut = is_new_fc_ ? NGMarginStrut() : margin_strut_;

  if (is_in_parallel_flow) {
    return new NGConstraintSpace(
        static_cast<NGWritingMode>(out_writing_mode),
        static_cast<TextDirection>(text_direction_), available_size,
        percentage_resolution_size, initial_containing_block_size_,
        fragmentainer_space_available_, is_fixed_size_inline_,
        is_fixed_size_block_, is_shrink_to_fit_,
        is_inline_direction_triggers_scrollbar_,
        is_block_direction_triggers_scrollbar_,
        static_cast<NGFragmentationType>(fragmentation_type_), is_new_fc_,
        margin_strut, bfc_offset, exclusions);
  }
  return new NGConstraintSpace(
      out_writing_mode, static_cast<TextDirection>(text_direction_),
      available_size, percentage_resolution_size,
      initial_containing_block_size_, fragmentainer_space_available_,
      is_fixed_size_block_, is_fixed_size_inline_, is_shrink_to_fit_,
      is_block_direction_triggers_scrollbar_,
      is_inline_direction_triggers_scrollbar_,
      static_cast<NGFragmentationType>(fragmentation_type_), is_new_fc_,
      margin_strut, bfc_offset, exclusions);
}

}  // namespace blink