// 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/geometry/path_builder.h"
#include "impeller/renderer/command_buffer.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) {
  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 = subpass->get()->GetElementsCoverage();
    } 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 = 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;
  auto subpass_pointer = pass.get();
  elements_.emplace_back(std::move(pass));
  return subpass_pointer;
}

bool EntityPass::Render(ContentContext& renderer,
                        RenderPass& parent_pass,
                        Point position) const {
  TRACE_EVENT0("impeller", "EntityPass::Render");

  for (const auto& element : elements_) {
    // =========================================================================
    // Entity rendering ========================================================
    // =========================================================================
    if (const auto& entity = std::get_if<Entity>(&element)) {
      Entity e = *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.
        e.SetTransformation(Matrix::MakeTranslation(Vector3(-position)) *
                            e.GetTransformation());
      }
      if (!e.Render(renderer, parent_pass)) {
        return false;
      }
      continue;
    }

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

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

      if (delegate_->CanCollapseIntoParentPass()) {
        // Directly render into the parent pass and move on.
        if (!subpass->Render(renderer, parent_pass, position)) {
          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;
      }

      auto context = renderer.GetContext();

      auto subpass_target = RenderTarget::CreateOffscreen(
          *context, ISize::Ceil(subpass_coverage->size));

      auto subpass_texture = subpass_target.GetRenderTargetTexture();

      if (!subpass_texture) {
        return false;
      }

      auto offscreen_texture_contents =
          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;
      }

      auto sub_command_buffer = context->CreateRenderCommandBuffer();

      if (!sub_command_buffer) {
        return false;
      }

      sub_command_buffer->SetLabel("Offscreen Command Buffer");

      auto sub_renderpass =
          sub_command_buffer->CreateRenderPass(subpass_target);

      if (!sub_renderpass) {
        return false;
      }

      sub_renderpass->SetLabel("OffscreenPass");

      if (!subpass->Render(renderer, *sub_renderpass,
                           subpass_coverage->origin)) {
        return false;
      }

      if (!sub_renderpass->EncodeCommands(*context->GetTransientsAllocator())) {
        return false;
      }

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

      Entity entity;
      entity.SetContents(std::move(offscreen_texture_contents));
      entity.SetStencilDepth(stencil_depth_);
      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.
      entity.SetTransformation(Matrix::MakeTranslation(
          Vector3(subpass_coverage->origin - position)));
      if (!entity.Render(renderer, parent_pass)) {
        return false;
      }

      continue;
    }

    FML_UNREACHABLE();
  }

  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