// Copyright 2013 The Flutter 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 "impeller/entity/entity_pass.h"

#include <variant>

#include "flutter/fml/logging.h"
#include "flutter/fml/trace_event.h"
#include "impeller/base/validation.h"
#include "impeller/entity/contents/content_context.h"
#include "impeller/entity/contents/filters/filter_contents.h"
#include "impeller/entity/contents/filters/inputs/filter_input.h"
#include "impeller/entity/contents/texture_contents.h"
#include "impeller/geometry/path_builder.h"
#include "impeller/renderer/allocator.h"
#include "impeller/renderer/command.h"
#include "impeller/renderer/command_buffer.h"
#include "impeller/renderer/formats.h"
#include "impeller/renderer/render_pass.h"
#include "impeller/renderer/texture.h"

namespace impeller {

EntityPass::EntityPass() = default;

EntityPass::~EntityPass() = default;

void EntityPass::SetDelegate(std::unique_ptr<EntityPassDelegate> delegate) {
  if (!delegate) {
    return;
  }
  delegate_ = std::move(delegate);
}

void EntityPass::AddEntity(Entity entity) {
  if (entity.GetBlendMode() > Entity::BlendMode::kLastPipelineBlendMode) {
    contains_advanced_blends_ = true;
  }

  elements_.emplace_back(std::move(entity));
}

void EntityPass::SetElements(std::vector<Element> elements) {
  elements_ = std::move(elements);
}

size_t EntityPass::GetSubpassesDepth() const {
  size_t max_subpass_depth = 0u;
  for (const auto& element : elements_) {
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      max_subpass_depth =
          std::max(max_subpass_depth, subpass->get()->GetSubpassesDepth());
    }
  }
  return max_subpass_depth + 1u;
}

const std::shared_ptr<LazyGlyphAtlas>& EntityPass::GetLazyGlyphAtlas() const {
  return lazy_glyph_atlas_;
}

std::optional<Rect> EntityPass::GetElementsCoverage() const {
  std::optional<Rect> result;
  for (const auto& element : elements_) {
    std::optional<Rect> coverage;

    if (auto entity = std::get_if<Entity>(&element)) {
      coverage = entity->GetCoverage();
    } else if (auto subpass =
                   std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      coverage = GetSubpassCoverage(*subpass->get());
    } else {
      FML_UNREACHABLE();
    }

    if (!result.has_value() && coverage.has_value()) {
      result = coverage;
      continue;
    }
    if (!coverage.has_value()) {
      continue;
    }
    result = result->Union(coverage.value());
  }
  return result;
}

std::optional<Rect> EntityPass::GetSubpassCoverage(
    const EntityPass& subpass) const {
  auto entities_coverage = subpass.GetElementsCoverage();
  // The entities don't cover anything. There is nothing to do.
  if (!entities_coverage.has_value()) {
    return std::nullopt;
  }

  // The delegates don't have an opinion on what the entity coverage has to be.
  // Just use that as-is.
  auto delegate_coverage = subpass.delegate_->GetCoverageRect();
  if (!delegate_coverage.has_value()) {
    return entities_coverage;
  }
  // The delegate coverage hint is in given in local space, so apply the subpass
  // transformation.
  delegate_coverage = delegate_coverage->TransformBounds(subpass.xformation_);

  // If the delegate tells us the coverage is smaller than it needs to be, then
  // great. OTOH, if the delegate is being wasteful, limit coverage to what is
  // actually needed.
  return entities_coverage->Intersection(delegate_coverage.value());
}

EntityPass* EntityPass::GetSuperpass() const {
  return superpass_;
}

EntityPass* EntityPass::AddSubpass(std::unique_ptr<EntityPass> pass) {
  if (!pass) {
    return nullptr;
  }
  FML_DCHECK(pass->superpass_ == nullptr);
  pass->superpass_ = this;

  if (pass->blend_mode_ > Entity::BlendMode::kLastPipelineBlendMode) {
    contains_advanced_blends_ = true;
  }

  auto subpass_pointer = pass.get();
  elements_.emplace_back(std::move(pass));
  return subpass_pointer;
}

bool EntityPass::Render(ContentContext& renderer,
                        RenderTarget render_target) const {
  if (contains_advanced_blends_) {
    auto offscreen_target = RenderTarget::CreateOffscreen(
        *renderer.GetContext(), render_target.GetRenderTargetSize(),
        "EntityPass",  //
        StorageMode::kDevicePrivate, LoadAction::kClear, StoreAction::kStore,
        StorageMode::kDevicePrivate, LoadAction::kClear, StoreAction::kStore);
    if (!RenderInternal(renderer, offscreen_target, Point(), 0)) {
      return false;
    }

    auto command_buffer = renderer.GetContext()->CreateRenderCommandBuffer();
    command_buffer->SetLabel("EntityPass Root Command Buffer");
    auto render_pass = command_buffer->CreateRenderPass(render_target);
    render_pass->SetLabel("EntityPass Root Render Pass");

    {
      auto size_rect =
          Rect::MakeSize(Size(offscreen_target.GetRenderTargetSize()));
      auto contents = std::make_shared<TextureContents>();
      contents->SetPath(PathBuilder{}.AddRect(size_rect).TakePath());
      contents->SetTexture(offscreen_target.GetRenderTargetTexture());
      contents->SetSourceRect(size_rect);

      Entity entity;
      entity.SetContents(contents);
      entity.SetBlendMode(Entity::BlendMode::kSourceOver);

      entity.Render(renderer, *render_pass);
    }

    if (!render_pass->EncodeCommands(
            renderer.GetContext()->GetTransientsAllocator())) {
      return false;
    }
    if (!command_buffer->SubmitCommands()) {
      return false;
    }

    return true;
  }

  return RenderInternal(renderer, render_target, Point(), 0);
}

bool EntityPass::RenderInternal(ContentContext& renderer,
                                RenderTarget render_target,
                                Point position,
                                uint32_t pass_depth,
                                size_t stencil_depth_floor) const {
  TRACE_EVENT0("impeller", "EntityPass::Render");

  auto context = renderer.GetContext();

  std::shared_ptr<CommandBuffer> command_buffer;
  std::shared_ptr<RenderPass> pass;
  uint32_t pass_count = 0;

  auto end_pass = [&command_buffer, &pass, &context]() {
    if (!pass->EncodeCommands(context->GetTransientsAllocator())) {
      return false;
    }

    if (!command_buffer->SubmitCommands()) {
      return false;
    }

    return true;
  };

  for (const auto& element : elements_) {
    Entity element_entity;

    // =========================================================================
    // Setup entity element for rendering ======================================
    // =========================================================================
    if (const auto& entity = std::get_if<Entity>(&element)) {
      element_entity = *entity;
      if (!position.IsZero()) {
        // If the pass image is going to be rendered with a non-zero position,
        // apply the negative translation to entity copies before rendering them
        // so that they'll end up rendering to the correct on-screen position.
        element_entity.SetTransformation(
            Matrix::MakeTranslation(Vector3(-position)) *
            element_entity.GetTransformation());
      }
    }

    // =========================================================================
    // Setup subpass element for rendering =====================================
    // =========================================================================
    else if (const auto& subpass_ptr =
                 std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      auto subpass = subpass_ptr->get();

      if (subpass->delegate_->CanElide()) {
        continue;
      }

      if (subpass->delegate_->CanCollapseIntoParentPass()) {
        // Directly render into the parent target and move on.
        if (!subpass->RenderInternal(renderer, render_target, position,
                                     pass_depth, stencil_depth_floor)) {
          return false;
        }
        continue;
      }

      const auto subpass_coverage = GetSubpassCoverage(*subpass);
      if (!subpass_coverage.has_value()) {
        continue;
      }

      if (subpass_coverage->size.IsEmpty()) {
        // It is not an error to have an empty subpass. But subpasses that can't
        // create their intermediates must trip errors.
        continue;
      }

      RenderTarget subpass_target;
      if (subpass->contains_advanced_blends_) {
        subpass_target = RenderTarget::CreateOffscreen(
            *context, ISize::Ceil(subpass_coverage->size), "EntityPass",
            StorageMode::kDevicePrivate, LoadAction::kClear,
            StoreAction::kStore, StorageMode::kDevicePrivate,
            LoadAction::kClear, StoreAction::kStore);
      } else {
        subpass_target = RenderTarget::CreateOffscreen(
            *context, ISize::Ceil(subpass_coverage->size), "EntityPass",
            StorageMode::kDevicePrivate, LoadAction::kClear,
            StoreAction::kStore, StorageMode::kDeviceTransient,
            LoadAction::kClear, StoreAction::kDontCare);
      }

      auto subpass_texture = subpass_target.GetRenderTargetTexture();

      if (!subpass_texture) {
        return false;
      }

      auto offscreen_texture_contents =
          subpass->delegate_->CreateContentsForSubpassTarget(subpass_texture);

      if (!offscreen_texture_contents) {
        // This is an error because the subpass delegate said the pass couldn't
        // be collapsed into its parent. Yet, when asked how it want's to
        // postprocess the offscreen texture, it couldn't give us an answer.
        //
        // Theoretically, we could collapse the pass now. But that would be
        // wasteful as we already have the offscreen texture and we don't want
        // to discard it without ever using it. Just make the delegate do the
        // right thing.
        return false;
      }

      // Stencil textures aren't shared between EntityPasses (as much of the
      // time they are transient).
      if (!subpass->RenderInternal(renderer, subpass_target,
                                   subpass_coverage->origin, ++pass_depth,
                                   subpass->stencil_depth_)) {
        return false;
      }

      element_entity.SetContents(std::move(offscreen_texture_contents));
      element_entity.SetStencilDepth(subpass->stencil_depth_);
      element_entity.SetBlendMode(subpass->blend_mode_);
      // Once we have filters being applied for SaveLayer, some special sauce
      // may be needed here (or in PaintPassDelegate) to ensure the filter
      // parameters are transformed by the `xformation_` matrix, while
      // continuing to apply only the subpass offset to the offscreen texture.
      element_entity.SetTransformation(Matrix::MakeTranslation(
          Vector3(subpass_coverage->origin - position)));
    } else {
      FML_UNREACHABLE();
    }

    // =========================================================================
    // Configure the RenderPass ================================================
    // =========================================================================

    if (pass && element_entity.GetBlendMode() >
                    Entity::BlendMode::kLastPipelineBlendMode) {
      // End the active pass and flush the buffer before rendering "advanced"
      // blends. Advanced blends work by binding the current render target
      // texture as an input ("destination"), blending with a second texture
      // input ("source"), writing the result to an intermediate texture, and
      // finally copying the data from the intermediate texture back to the
      // render target texture. And so all of the commands that have written to
      // the render target texture so far need to execute before it's bound for
      // blending (otherwise the blend pass will end up executing before all the
      // previous commands in the active pass).
      if (!end_pass()) {
        return false;
      }
      // Resetting these handles triggers a new pass to get created below
      pass = nullptr;
      command_buffer = nullptr;

      // Amend an advanced blend to the contents.
      if (render_target.GetColorAttachments().empty()) {
        return false;
      }
      auto color0 = render_target.GetColorAttachments().find(0)->second;

      FilterInput::Vector inputs = {
          FilterInput::Make(element_entity.GetContents()),
          FilterInput::Make(
              color0.resolve_texture ? color0.resolve_texture : color0.texture,
              element_entity.GetTransformation().Invert())};
      element_entity.SetContents(
          FilterContents::MakeBlend(element_entity.GetBlendMode(), inputs));
      element_entity.SetBlendMode(Entity::BlendMode::kSourceOver);
    }

    // Create a new render pass to render the element if one isn't active.
    if (!pass) {
      command_buffer = context->CreateRenderCommandBuffer();
      if (!command_buffer) {
        return false;
      }

      command_buffer->SetLabel(
          "EntityPass Command Buffer: Depth=" + std::to_string(pass_depth) +
          " Count=" + std::to_string(pass_count));

      // Never clear the texture for subsequent passes.
      if (pass_count > 0) {
        if (!render_target.GetColorAttachments().empty()) {
          auto color0 = render_target.GetColorAttachments().find(0)->second;
          color0.load_action = LoadAction::kLoad;
          render_target.SetColorAttachment(color0, 0);
        }

        if (auto stencil = render_target.GetStencilAttachment();
            stencil.has_value()) {
          stencil->load_action = LoadAction::kLoad;
          render_target.SetStencilAttachment(stencil.value());
        }
      }

      pass = command_buffer->CreateRenderPass(render_target);
      if (!pass) {
        return false;
      }

      pass->SetLabel(
          "EntityPass Render Pass: Depth=" + std::to_string(pass_depth) +
          " Count=" + std::to_string(pass_count));

      ++pass_count;
    }

    // =========================================================================
    // Render the element ======================================================
    // =========================================================================

    element_entity.SetStencilDepth(element_entity.GetStencilDepth() -
                                   stencil_depth_floor);

    if (!element_entity.Render(renderer, *pass)) {
      return false;
    }
  }

  if (pass) {
    return end_pass();
  }
  return true;
}

void EntityPass::IterateAllEntities(std::function<bool(Entity&)> iterator) {
  if (!iterator) {
    return;
  }

  for (auto& element : elements_) {
    if (auto entity = std::get_if<Entity>(&element)) {
      if (!iterator(*entity)) {
        return;
      }
      continue;
    }
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      subpass->get()->IterateAllEntities(iterator);
      continue;
    }
    FML_UNREACHABLE();
  }
}

std::unique_ptr<EntityPass> EntityPass::Clone() const {
  std::vector<Element> new_elements;
  new_elements.reserve(elements_.size());

  for (const auto& element : elements_) {
    if (auto entity = std::get_if<Entity>(&element)) {
      new_elements.push_back(*entity);
      continue;
    }
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      new_elements.push_back(subpass->get()->Clone());
      continue;
    }
    FML_UNREACHABLE();
  }

  auto pass = std::make_unique<EntityPass>();
  pass->SetElements(std::move(new_elements));
  return pass;
}

void EntityPass::SetTransformation(Matrix xformation) {
  xformation_ = std::move(xformation);
}

void EntityPass::SetStencilDepth(size_t stencil_depth) {
  stencil_depth_ = stencil_depth;
}

void EntityPass::SetBlendMode(Entity::BlendMode blend_mode) {
  blend_mode_ = blend_mode;
}

}  // namespace impeller