#include "rive/animation/keyframe_interpolator.hpp"
#include "rive/core_context.hpp"
#include "rive/layout_component.hpp"
#include "rive/layout/layout_component_style.hpp"
#include "rive/layout/layout_style_applier.hpp"
#include "rive/layout/grid_track.hpp"
#ifdef WITH_RIVE_LAYOUT
// YGStyle is only forward declared in the headers; the setters below need it.
#include "rive/layout/layout_data.hpp"
#endif
#include <vector>

using namespace rive;

#ifdef WITH_RIVE_LAYOUT
// Stack alignment: the 9-way selector sets the default cell placement via grid
// justifyItems (horizontal) + alignItems (vertical). Per-child
// justifySelf/alignSelf still overrides. space-between collapses to start.
static void applyStackAlignment(YGStyle& ygStyle, LayoutAlignmentType t)
{
  switch (t)
  {
    case LayoutAlignmentType::topLeft:
    case LayoutAlignmentType::centerLeft:
    case LayoutAlignmentType::bottomLeft:
    case LayoutAlignmentType::spaceBetweenStart:
      ygStyle.setJustifyItems(YGJustifyStart);
      break;
    case LayoutAlignmentType::topCenter:
    case LayoutAlignmentType::center:
    case LayoutAlignmentType::bottomCenter:
    case LayoutAlignmentType::spaceBetweenCenter:
      ygStyle.setJustifyItems(YGJustifyCenter);
      break;
    case LayoutAlignmentType::topRight:
    case LayoutAlignmentType::centerRight:
    case LayoutAlignmentType::bottomRight:
    case LayoutAlignmentType::spaceBetweenEnd:
      ygStyle.setJustifyItems(YGJustifyEnd);
      break;
  }
  switch (t)
  {
    case LayoutAlignmentType::topLeft:
    case LayoutAlignmentType::topCenter:
    case LayoutAlignmentType::topRight:
      ygStyle.alignItems() = YGAlignStart;
      break;
    case LayoutAlignmentType::centerLeft:
    case LayoutAlignmentType::center:
    case LayoutAlignmentType::centerRight:
      ygStyle.alignItems() = YGAlignCenter;
      break;
    case LayoutAlignmentType::bottomLeft:
    case LayoutAlignmentType::bottomCenter:
    case LayoutAlignmentType::bottomRight:
      ygStyle.alignItems() = YGAlignEnd;
      break;
    case LayoutAlignmentType::spaceBetweenStart:
    case LayoutAlignmentType::spaceBetweenCenter:
    case LayoutAlignmentType::spaceBetweenEnd:
      ygStyle.alignItems() = YGAlignStart;
      break;
  }
}
#endif

#ifdef WITH_RIVE_LAYOUT
// How this layout sits inside its own parent.
void LayoutComponentStyle::applyItemStyle(
    YGStyle& style,
    const LayoutSyncContext& context)
{
  LayoutSizingStyle::applyItemStyle(style, context);

  style.positionType() = positionType();
  style.aspectRatio() = YGFloatOptional(
      aspectRatio() > 0 ? aspectRatio() : NAN);
  // A data binding can write any value. Out of range reads as auto, so the
  // flex, absolute and grid paths agree on it instead of each reading the
  // stray bits its own way.
  const auto axisValue = aspectRatioAxisValue();
  style.aspectRatioAxis() = axisValue <= YGAspectRatioAxisHeight
                                ? YGAspectRatioAxis(axisValue)
                                : YGAspectRatioAxisAuto;

  const auto startEdge = context.isLTR ? YGEdgeLeft : YGEdgeRight;
  const auto endEdge = context.isLTR ? YGEdgeRight : YGEdgeLeft;
  // No parent to take a percentage of, so margins resolve as points.
  const auto marginUnits = [&](YGUnit units) {
    return context.hasLayoutParent ? units : YGUnitPoint;
  };

  style.margin()[startEdge] = YGValue{
      marginLeft(),
      marginUnits(marginLeftUnits())};
  style.margin()[endEdge] = YGValue{
      marginRight(),
      marginUnits(marginRightUnits())};
  style.margin()[YGEdgeTop] = YGValue{
      marginTop(),
      marginUnits(marginTopUnits())};
  style.margin()[YGEdgeBottom] = YGValue{
      marginBottom(),
      marginUnits(marginBottomUnits())};

  style.position()[startEdge] = YGValue{positionLeft(), positionLeftUnits()};
  style.position()[endEdge] = YGValue{positionRight(), positionRightUnits()};
  style.position()[YGEdgeTop] = YGValue{positionTop(), positionTopUnits()};
  style.position()[YGEdgeBottom] = YGValue{
      positionBottom(),
      positionBottomUnits()};
}
#endif

#ifdef WITH_RIVE_LAYOUT
// What this layout imposes on its children: their box (padding/border/gap) and
// the alignment selector, resolved onto our own axes by containerAlignment.
void LayoutComponentStyle::applyContainerStyle(
    YGStyle& style,
    const LayoutSyncContext& context)
{
  const auto startEdge = context.isLTR ? YGEdgeLeft : YGEdgeRight;
  const auto endEdge = context.isLTR ? YGEdgeRight : YGEdgeLeft;

  style.flexDirection() = flexDirection();
  style.flexWrap() = flexWrap();
  style.direction() = direction();

  style.gap()[YGGutterColumn] = YGValue{gapHorizontal(), gapHorizontalUnits()};
  style.gap()[YGGutterRow] = YGValue{gapVertical(), gapVerticalUnits()};

  style.border()[startEdge] = YGValue{borderLeft(), borderLeftUnits()};
  style.border()[endEdge] = YGValue{borderRight(), borderRightUnits()};
  style.border()[YGEdgeTop] = YGValue{borderTop(), borderTopUnits()};
  style.border()[YGEdgeBottom] = YGValue{borderBottom(), borderBottomUnits()};

  style.padding()[startEdge] = YGValue{paddingLeft(), paddingLeftUnits()};
  style.padding()[endEdge] = YGValue{paddingRight(), paddingRightUnits()};
  style.padding()[YGEdgeTop] = YGValue{paddingTop(), paddingTopUnits()};
  style.padding()[YGEdgeBottom] = YGValue{
      paddingBottom(),
      paddingBottomUnits()};

  // A stack is one implicit cell, aligned through justifyItems/alignItems
  // rather than the flex selector below.
  if (isStack())
  {
    GridTrack::syncStackContainerStyle(style, justifyItemsValue());
    applyStackAlignment(style, alignmentType());
    return;
  }
  // Our own main axis, not the parent's: this aligns the children we lay out.
  const bool isRow = flexDirection() == YGFlexDirectionRow ||
                     flexDirection() == YGFlexDirectionRowReverse;
  auto alignment = containerAlignment(alignmentType(), isRow);
  switch (alignment.main)
  {
    case LayoutMainDistribute::start:
      style.justifyContent() = YGJustifyFlexStart;
      break;
    case LayoutMainDistribute::center:
      style.justifyContent() = YGJustifyCenter;
      break;
    case LayoutMainDistribute::end:
      style.justifyContent() = YGJustifyFlexEnd;
      break;
    case LayoutMainDistribute::spaceBetween:
      style.justifyContent() = YGJustifySpaceBetween;
      break;
  }
  YGAlign cross = alignment.cross == LayoutCrossAlign::start ? YGAlignFlexStart
                  : alignment.cross == LayoutCrossAlign::center
                      ? YGAlignCenter
                      : YGAlignFlexEnd;
  style.alignItems() = cross;
  style.alignContent() = cross;
}
#endif

#ifdef WITH_RIVE_LAYOUT

KeyFrameInterpolator* LayoutComponentStyle::interpolator()
{
  return m_interpolator;
}

LayoutStyleInterpolation LayoutComponentStyle::interpolation()
{
  return LayoutStyleInterpolation(interpolationType());
}

LayoutAnimationStyle LayoutComponentStyle::animationStyle()
{
  return LayoutAnimationStyle(animationStyleType());
}

LayoutAlignmentType LayoutComponentStyle::alignmentType()
{
  return LayoutAlignmentType(layoutAlignmentType());
}

LayoutScaleType LayoutComponentStyle::widthScaleType()
{
  return LayoutScaleType(layoutWidthScaleType());
}

LayoutScaleType LayoutComponentStyle::heightScaleType()
{
  return LayoutScaleType(layoutHeightScaleType());
}

YGDisplay LayoutComponentStyle::display()
{
  // displayValue is visibility only (flex/none); layoutTypeValue selects the
  // algorithm. Hidden wins, else flex or grid (stack also drives the grid).
  if (YGDisplay(displayValue()) == YGDisplayNone)
  {
    return YGDisplayNone;
  }
  return layoutTypeValue() == 0 ? YGDisplayFlex : YGDisplayGrid;
}

YGPositionType LayoutComponentStyle::positionType()
{
  return YGPositionType(positionTypeValue());
}

YGFlexDirection LayoutComponentStyle::flexDirection()
{
  return YGFlexDirection(flexDirectionValue());
}

YGDirection LayoutComponentStyle::direction()
{
  return YGDirection(directionValue());
}

YGWrap LayoutComponentStyle::flexWrap() { return YGWrap(flexWrapValue()); }

YGOverflow LayoutComponentStyle::overflow()
{
  return YGOverflow(overflowValue());
}

bool LayoutComponentStyle::intrinsicallySized()
{
  return intrinsicallySizedValue() == 1;
}

YGUnit LayoutComponentStyle::widthUnits() { return YGUnit(widthUnitsValue()); }

YGUnit LayoutComponentStyle::heightUnits()
{
  return YGUnit(heightUnitsValue());
}

YGUnit LayoutComponentStyle::borderLeftUnits()
{
  return YGUnit(borderLeftUnitsValue());
}

YGUnit LayoutComponentStyle::borderRightUnits()
{
  return YGUnit(borderRightUnitsValue());
}

YGUnit LayoutComponentStyle::borderTopUnits()
{
  return YGUnit(borderTopUnitsValue());
}

YGUnit LayoutComponentStyle::borderBottomUnits()
{
  return YGUnit(borderBottomUnitsValue());
}

YGUnit LayoutComponentStyle::marginLeftUnits()
{
  return YGUnit(marginLeftUnitsValue());
}

YGUnit LayoutComponentStyle::marginRightUnits()
{
  return YGUnit(marginRightUnitsValue());
}

YGUnit LayoutComponentStyle::marginTopUnits()
{
  return YGUnit(marginTopUnitsValue());
}

YGUnit LayoutComponentStyle::marginBottomUnits()
{
  return YGUnit(marginBottomUnitsValue());
}

YGUnit LayoutComponentStyle::paddingLeftUnits()
{
  return YGUnit(paddingLeftUnitsValue());
}

YGUnit LayoutComponentStyle::paddingRightUnits()
{
  return YGUnit(paddingRightUnitsValue());
}

YGUnit LayoutComponentStyle::paddingTopUnits()
{
  return YGUnit(paddingTopUnitsValue());
}

YGUnit LayoutComponentStyle::paddingBottomUnits()
{
  return YGUnit(paddingBottomUnitsValue());
}

YGUnit LayoutComponentStyle::positionLeftUnits()
{
  return YGUnit(positionLeftUnitsValue());
}

YGUnit LayoutComponentStyle::positionRightUnits()
{
  return YGUnit(positionRightUnitsValue());
}

YGUnit LayoutComponentStyle::positionTopUnits()
{
  return YGUnit(positionTopUnitsValue());
}

YGUnit LayoutComponentStyle::positionBottomUnits()
{
  return YGUnit(positionBottomUnitsValue());
}

YGUnit LayoutComponentStyle::gapHorizontalUnits()
{
  return YGUnit(gapHorizontalUnitsValue());
}

YGUnit LayoutComponentStyle::gapVerticalUnits()
{
  return YGUnit(gapVerticalUnitsValue());
}

YGUnit LayoutComponentStyle::flexBasisUnits()
{
  return YGUnit(flexBasisUnitsValue());
}

void LayoutComponentStyle::markLayoutNodeDirty()
{
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->markLayoutNodeDirty();
  }
}

void LayoutComponentStyle::markLayoutStyleDirty()
{
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->markLayoutStyleDirty();
  }
}

void LayoutComponentStyle::markRenderPathDirty()
{
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->addDirt(ComponentDirt::Path);
  }
}

void LayoutComponentStyle::scaleTypeChanged()
{
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->scaleTypeChanged();
  }
}

void LayoutComponentStyle::displayChanged()
{
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->displayChanged();
  }
}

void LayoutComponentStyle::positionTypeValueChanged()
{
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->positionTypeChanged();
  }
}

void LayoutComponentStyle::flexDirectionValueChanged()
{
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->flexDirectionChanged();
  }
}

void LayoutComponentStyle::directionValueChanged()
{
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->directionChanged();
  }
}

StatusCode LayoutComponentStyle::onAddedDirty(CoreContext* context)
{
  auto code = Super::onAddedDirty(context);
  if (code != StatusCode::Ok)
  {
    return code;
  }

  auto coreObject = context->resolve(interpolatorId());
  if (coreObject != nullptr && coreObject->is<KeyFrameInterpolator>())
  {
    m_interpolator = static_cast<KeyFrameInterpolator*>(coreObject);
  }
  return StatusCode::Ok;
}
#else
void LayoutComponentStyle::markLayoutNodeDirty() {}
void LayoutComponentStyle::markLayoutStyleDirty() {}
void LayoutComponentStyle::markRenderPathDirty() {}
void LayoutComponentStyle::scaleTypeChanged() {}
void LayoutComponentStyle::displayChanged() {}
void LayoutComponentStyle::positionTypeValueChanged() {}
void LayoutComponentStyle::flexDirectionValueChanged() {}
void LayoutComponentStyle::directionValueChanged() {}
#endif

void LayoutComponentStyle::interpolationTimeChanged()
{
  markLayoutStyleDirty();
}
void LayoutComponentStyle::layoutAlignmentTypeChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::layoutWidthScaleTypeChanged() { scaleTypeChanged(); }
void LayoutComponentStyle::layoutHeightScaleTypeChanged()
{
  scaleTypeChanged();
}
void LayoutComponentStyle::hugUnboundedChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::displayValueChanged() { displayChanged(); }
void LayoutComponentStyle::layoutTypeValueChanged()
{
#ifdef WITH_RIVE_LAYOUT
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->layoutTypeChanged();
  }
#endif
}
void LayoutComponentStyle::justifyItemsValueChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::justifySelfValueChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::overflowValueChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::intrinsicallySizedValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::flexWrapValueChanged() { markLayoutNodeDirty(); }

void LayoutComponentStyle::flexBasisChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::aspectRatioChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::aspectRatioAxisValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::gapHorizontalChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::gapVerticalChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::maxWidthChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::maxHeightChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::minWidthChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::minHeightChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::borderLeftChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::borderRightChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::borderTopChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::borderBottomChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::marginLeftChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::marginRightChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::marginTopChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::marginBottomChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::paddingLeftChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::paddingRightChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::paddingTopChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::paddingBottomChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::positionLeftChanged()
{
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->markPositionLeftChanged();
  }
  markLayoutNodeDirty();
}
void LayoutComponentStyle::positionRightChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::positionTopChanged()
{
  if (parent()->is<LayoutComponent>())
  {
    parent()->as<LayoutComponent>()->markPositionTopChanged();
  }
  markLayoutNodeDirty();
}
void LayoutComponentStyle::positionBottomChanged() { markLayoutNodeDirty(); }

void LayoutComponentStyle::widthUnitsValueChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::heightUnitsValueChanged() { markLayoutNodeDirty(); }
void LayoutComponentStyle::gapHorizontalUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::gapVerticalUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::maxWidthUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::maxHeightUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::minWidthUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::minHeightUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::borderLeftUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::borderRightUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::borderTopUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::borderBottomUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::marginLeftUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::marginRightUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::marginTopUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::marginBottomUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::paddingLeftUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::paddingRightUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::paddingTopUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::paddingBottomUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::positionLeftUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::positionRightUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::positionTopUnitsValueChanged()
{
  markLayoutNodeDirty();
}
void LayoutComponentStyle::positionBottomUnitsValueChanged()
{
  markLayoutNodeDirty();
}
// The corner radiuses are read only by LayoutComponent::updateRenderPath, to
// round the layout's background, so a change just rebuilds that path.
// markLayoutStyleDirty would also re-cascade styles through the artboard's
// whole layout tree, and until that cascade ran, an inherit-style layout would
// lose its interpolation and skip that frame's tween step. linkCornerRadius
// decides which of the four radiuses the path uses, so it rebuilds the path
// too; that matters most when the flag is data bound and flips mid-playback.
void LayoutComponentStyle::linkCornerRadiusChanged() { markRenderPathDirty(); }
void LayoutComponentStyle::cornerRadiusTLChanged() { markRenderPathDirty(); }
void LayoutComponentStyle::cornerRadiusTRChanged() { markRenderPathDirty(); }
void LayoutComponentStyle::cornerRadiusBLChanged() { markRenderPathDirty(); }
void LayoutComponentStyle::cornerRadiusBRChanged() { markRenderPathDirty(); }