/*
 * Copyright (C) 2012 Apple 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. ``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 COMPUTER, INC. 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.
 */

#ifndef LayoutMultiColumnFlowThread_h
#define LayoutMultiColumnFlowThread_h

#include "core/CoreExport.h"
#include "core/layout/FragmentationContext.h"
#include "core/layout/LayoutFlowThread.h"

namespace blink {

class LayoutMultiColumnSet;
class LayoutMultiColumnSpannerPlaceholder;

// What to translate *to* when translating from a flow thread coordinate space.
enum class CoordinateSpaceConversion {
  // Just translate to the nearest containing coordinate space (i.e. where our
  // multicol container lives) of this flow thread, i.e. don't walk ancestral
  // flow threads, if any.
  Containing,

  // Translate to visual coordinates, by walking all ancestral flow threads.
  Visual
};

// Flow thread implementation for CSS multicol. This will be inserted as an
// anonymous child block of the actual multicol container (i.e. the
// LayoutBlockFlow whose style computes to non-auto column-count and/or
// column-width). LayoutMultiColumnFlowThread is the heart of the multicol
// implementation, and there is only one instance per multicol container. Child
// content of the multicol container is parented into the flow thread at the
// time of layoutObject insertion.
//
// Apart from this flow thread child, the multicol container will also have
// LayoutMultiColumnSet children, which are used to position the columns
// visually. The flow thread is in charge of layout, and, after having
// calculated the column width, it lays out content as if everything were in one
// tall single column, except that there will typically be some amount of blank
// space (also known as pagination struts) at the offsets where the actual
// column boundaries are. This way, content that needs to be preceded by a break
// will appear at the top of the next column. Content needs to be preceded by a
// break when there's a forced break or when the content is unbreakable and
// cannot fully fit in the same column as the preceding piece of content.
// Although a LayoutMultiColumnFlowThread is laid out, it does not take up any
// space in its container. It's the LayoutMultiColumnSet objects that take up
// the necessary amount of space, and make sure that the columns are painted and
// hit-tested correctly.
//
// If there is any column content inside the multicol container, we create a
// LayoutMultiColumnSet. We only need to create multiple sets if there are
// spanners (column-span:all) in the multicol container. When a spanner is
// inserted, content preceding it gets its own set, and content succeeding it
// will get another set. The spanner itself will also get its own placeholder
// between the sets (LayoutMultiColumnSpannerPlaceholder), so that it gets
// positioned and sized correctly. The column-span:all element is inside the
// flow thread, but its containing block is the multicol container.
//
// Some invariants for the layout tree structure for multicol:
// - A multicol container is always a LayoutBlockFlow
// - Every multicol container has one and only one LayoutMultiColumnFlowThread
// - All multicol DOM children and pseudo-elements associated with the multicol
//   container are reparented into the flow thread.
// - The LayoutMultiColumnFlowThread is the first child of the multicol
//   container.
// - A multicol container may only have LayoutMultiColumnFlowThread,
//   LayoutMultiColumnSet and LayoutMultiColumnSpannerPlaceholder children.
// - A LayoutMultiColumnSet may not be adjacent to another LayoutMultiColumnSet;
//   there are no use-cases for it, and there are also implementation
//   limitations behind this requirement.
// - The flow thread is not in the containing block chain for children that are
//   not to be laid out in columns. This means column spanners and absolutely
//   positioned children whose containing block is outside column content
// - Each spanner (column-span:all) establishes a
//   LayoutMultiColumnSpannerPlaceholder
//
// The width of the flow thread is the same as the column width. The width of a
// column set is the same as the content box width of the multicol container; in
// other words exactly enough to hold the number of columns to be used, stacked
// horizontally, plus column gaps between them.
//
// Since it's the first child of the multicol container, the flow thread is laid
// out first, albeit in a slightly special way, since it's not to take up any
// space in its ancestors. Afterwards, the column sets are laid out. Column sets
// get their height from the columns that they hold. In single column-row
// constrained height non-balancing cases without spanners this will simply be
// the same as the content height of the multicol container itself. In most
// other cases we'll have to calculate optimal column heights ourselves, though.
// This process is referred to as column balancing, and then we infer the column
// set height from the height of the flow thread portion occupied by each set.
//
// More on column balancing: the columns' height is unknown in the first layout
// pass when balancing. This means that we cannot insert any implicit (soft /
// unforced) breaks (and pagination struts) when laying out the contents of the
// flow thread. We'll just lay out everything in tall single strip. After the
// initial flow thread layout pass we can determine a tentative / minimal /
// initial column height. This is calculated by simply dividing the flow
// thread's height by the number of specified columns. In the layout pass that
// follows, we can insert breaks (and pagination struts) at column boundaries,
// since we now have a column height.
// It may very easily turn out that the calculated height wasn't enough, though.
// We'll notice this at end of layout. If we end up with too many columns (i.e.
// columns overflowing the multicol container), it wasn't enough. In this case
// we need to increase the column heights. We'll increase them by the lowest
// amount of space that could possibly affect where the breaks occur. We'll
// relayout (to find new break points and the new lowest amount of space
// increase that could affect where they occur, in case we need another round)
// until we've reached an acceptable height (where everything fits perfectly in
// the number of columns that we have specified). The rule of thumb is that we
// shouldn't have to perform more of such iterations than the number of columns
// that we have.
//
// For each layout iteration done for column balancing, the flow thread will
// need a deep layout if column heights changed in the previous pass, since
// column height changes may affect break points and pagination struts anywhere
// in the tree, and currently no way exists to do this in a more optimized
// manner.
//
// There's also some documentation online:
// https://www.chromium.org/developers/design-documents/multi-column-layout
class CORE_EXPORT LayoutMultiColumnFlowThread : public LayoutFlowThread,
                                                public FragmentationContext {
 public:
  ~LayoutMultiColumnFlowThread() override;

  static LayoutMultiColumnFlowThread* createAnonymous(
      Document&,
      const ComputedStyle& parentStyle);

  bool isLayoutMultiColumnFlowThread() const final { return true; }

  LayoutBlockFlow* multiColumnBlockFlow() const {
    return toLayoutBlockFlow(parent());
  }

  LayoutMultiColumnSet* firstMultiColumnSet() const;
  LayoutMultiColumnSet* lastMultiColumnSet() const;

  // Return the first column set or spanner placeholder.
  LayoutBox* firstMultiColumnBox() const { return nextSiblingBox(); }
  // Return the last column set or spanner placeholder.
  LayoutBox* lastMultiColumnBox() const {
    LayoutBox* lastSiblingBox = multiColumnBlockFlow()->lastChildBox();
    // The flow thread is the first child of the multicol container. If the flow
    // thread is also the last child, it means that there are no siblings; i.e.
    // we have no column boxes.
    return lastSiblingBox != this ? lastSiblingBox : 0;
  }

  // Find the first set inside which the specified layoutObject (which is a
  // flowthread descendant) would be rendered.
  LayoutMultiColumnSet* mapDescendantToColumnSet(LayoutObject*) const;

  // Return the spanner placeholder that belongs to the spanner in the
  // containing block chain, if any. This includes the layoutObject for the
  // element that actually establishes the spanner too.
  LayoutMultiColumnSpannerPlaceholder* containingColumnSpannerPlaceholder(
      const LayoutObject* descendant) const;

  // Populate the flow thread with what's currently its siblings. Called when a
  // regular block becomes a multicol container.
  void populate();

  // Empty the flow thread by moving everything to the parent. Remove all
  // multicol specific layoutObjects. Then destroy the flow thread. Called when
  // a multicol container becomes a regular block.
  void evacuateAndDestroy();

  unsigned columnCount() const { return m_columnCount; }

  // Total height available to columns and spanners. This is the multicol
  // container's content box logical height, or 0 if auto.
  LayoutUnit columnHeightAvailable() const { return m_columnHeightAvailable; }
  void setColumnHeightAvailable(LayoutUnit available) {
    m_columnHeightAvailable = available;
  }

  // Maximum content box logical height for the multicol container. This takes
  // CSS logical 'height' and 'max-height' into account. LayoutUnit::max() is
  // returned if nothing constrains the height of the multicol container. This
  // method only deals with used values of CSS properties, and it does not
  // consider enclosing fragmentation contexts -- that's something that needs to
  // be calculated per fragmentainer group.
  LayoutUnit maxColumnLogicalHeight() const;

  bool progressionIsInline() const { return m_progressionIsInline; }

  LayoutUnit tallestUnbreakableLogicalHeight(
      LayoutUnit offsetInFlowThread) const;

  LayoutSize columnOffset(const LayoutPoint&) const final;

  // Do we need to set a new width and lay out?
  virtual bool needsNewWidth() const;

  bool isPageLogicalHeightKnown() const final;
  bool mayHaveNonUniformPageLogicalHeight() const final;

  LayoutSize flowThreadTranslationAtOffset(LayoutUnit,
                                           PageBoundaryRule,
                                           CoordinateSpaceConversion) const;
  LayoutSize flowThreadTranslationAtPoint(const LayoutPoint& flowThreadPoint,
                                          CoordinateSpaceConversion) const;

  LayoutPoint flowThreadPointToVisualPoint(
      const LayoutPoint& flowThreadPoint) const override;
  LayoutPoint visualPointToFlowThreadPoint(
      const LayoutPoint& visualPoint) const override;

  int inlineBlockBaseline(LineDirectionMode) const override;

  LayoutMultiColumnSet* columnSetAtBlockOffset(LayoutUnit,
                                               PageBoundaryRule) const final;

  void layoutColumns(SubtreeLayoutScope&);

  // Skip past a column spanner during flow thread layout. Spanners are not laid
  // out inside the flow thread, since the flow thread is not in a spanner's
  // containing block chain (since the containing block is the multicol
  // container).
  void skipColumnSpanner(LayoutBox*, LayoutUnit logicalTopInFlowThread);

  // Returns true if at least one column got a new height after flow thread
  // layout (during column set layout), in which case we need another layout
  // pass. Column heights may change after flow thread layout because of
  // balancing. We may have to do multiple layout passes, depending on how the
  // contents is fitted to the changed column heights. In most cases, laying out
  // again twice or even just once will suffice. Sometimes we need more passes
  // than that, though, but the number of retries should not exceed the number
  // of columns, unless we have a bug.
  bool columnHeightsChanged() const { return m_columnHeightsChanged; }
  void setColumnHeightsChanged() { m_columnHeightsChanged = true; }

  void columnRuleStyleDidChange();

  // Remove the spanner placeholder and return true if the specified object is
  // no longer a valid spanner.
  bool removeSpannerPlaceholderIfNoLongerValid(
      LayoutBox* spannerObjectInFlowThread);

  LayoutMultiColumnFlowThread* enclosingFlowThread() const;
  FragmentationContext* enclosingFragmentationContext() const;
  LayoutUnit blockOffsetInEnclosingFragmentationContext() const {
    ASSERT(enclosingFragmentationContext());
    return m_blockOffsetInEnclosingFragmentationContext;
  }

  // If we've run out of columns in the last fragmentainer group (column row),
  // we have to insert another fragmentainer group in order to hold more
  // columns. This means that we're moving to the next outer column (in the
  // enclosing fragmentation context).
  void appendNewFragmentainerGroupIfNeeded(LayoutUnit offsetInFlowThread,
                                           PageBoundaryRule);

  // Implementing FragmentationContext:
  bool isFragmentainerLogicalHeightKnown() final;
  LayoutUnit fragmentainerLogicalHeightAt(LayoutUnit blockOffset) final;
  LayoutUnit remainingLogicalHeightAt(LayoutUnit blockOffset) final;
  LayoutMultiColumnFlowThread* associatedFlowThread() final { return this; }

  const char* name() const override { return "LayoutMultiColumnFlowThread"; }

 protected:
  LayoutMultiColumnFlowThread();
  void setProgressionIsInline(bool isInline) {
    m_progressionIsInline = isInline;
  }

  void layout() override;

 private:
  void calculateColumnHeightAvailable();
  void calculateColumnCountAndWidth(LayoutUnit& width, unsigned& count) const;
  void createAndInsertMultiColumnSet(LayoutBox* insertBefore = nullptr);
  void createAndInsertSpannerPlaceholder(
      LayoutBox* spannerObjectInFlowThread,
      LayoutObject* insertedBeforeInFlowThread);
  void destroySpannerPlaceholder(LayoutMultiColumnSpannerPlaceholder*);
  virtual bool descendantIsValidColumnSpanner(LayoutObject* descendant) const;

  void addColumnSetToThread(LayoutMultiColumnSet*) override;
  void willBeRemovedFromTree() override;
  void flowThreadDescendantWasInserted(LayoutObject*) final;
  void flowThreadDescendantWillBeRemoved(LayoutObject*) final;
  void flowThreadDescendantStyleWillChange(
      LayoutBox*,
      StyleDifference,
      const ComputedStyle& newStyle) override;
  void flowThreadDescendantStyleDidChange(
      LayoutBox*,
      StyleDifference,
      const ComputedStyle& oldStyle) override;
  void toggleSpannersInSubtree(LayoutBox*);
  void computePreferredLogicalWidths() override;
  void computeLogicalHeight(LayoutUnit logicalHeight,
                            LayoutUnit logicalTop,
                            LogicalExtentComputedValues&) const override;
  void updateLogicalWidth() override;
  void contentWasLaidOut(
      LayoutUnit logicalBottomInFlowThreadAfterPagination) override;
  bool canSkipLayout(const LayoutBox&) const override;
  MultiColumnLayoutState multiColumnLayoutState() const override;
  void restoreMultiColumnLayoutState(const MultiColumnLayoutState&) override;

  // The last set we worked on. It's not to be used as the "current set". The
  // concept of a "current set" is difficult, since layout may jump back and
  // forth in the tree, due to wrong top location estimates (due to e.g. margin
  // collapsing), and possibly for other reasons.
  LayoutMultiColumnSet* m_lastSetWorkedOn;

#if DCHECK_IS_ON()
  // Used to check consistency between calls to
  // flowThreadDescendantStyleWillChange() and
  // flowThreadDescendantStyleDidChange().
  static const LayoutBox* s_styleChangedBox;
#endif

  // The used value of column-count
  unsigned m_columnCount;
  // Total height available to columns, or 0 if auto.
  LayoutUnit m_columnHeightAvailable;

  // Cached block offset from this flow thread to the enclosing fragmentation
  // context, if any. In
  // the coordinate space of the enclosing fragmentation context.
  LayoutUnit m_blockOffsetInEnclosingFragmentationContext;

  // Set when column heights are out of sync with actual layout.
  bool m_columnHeightsChanged;

  // Always true for regular multicol. False for paged-y overflow.
  bool m_progressionIsInline;

  bool m_isBeingEvacuated;

  // Specifies whether the the descendant whose style is about to change could
  // contain spanners or not. The flag is set in
  // flowThreadDescendantStyleWillChange(), and then checked in
  // flowThreadDescendantStyleDidChange().
  static bool s_couldContainSpanners;

  static bool s_toggleSpannersIfNeeded;
};

// Cannot use DEFINE_LAYOUT_OBJECT_TYPE_CASTS here, because
// isMultiColumnFlowThread() is defined in LayoutFlowThread, not in
// LayoutObject.
DEFINE_TYPE_CASTS(LayoutMultiColumnFlowThread,
                  LayoutFlowThread,
                  object,
                  object->isLayoutMultiColumnFlowThread(),
                  object.isLayoutMultiColumnFlowThread());

}  // namespace blink

#endif  // LayoutMultiColumnFlowThread_h