#include <mbgl/geometry/feature_index.hpp>
#include <mbgl/gfx/context.hpp>
#include <mbgl/gfx/drawable_builder.hpp>
#include <mbgl/gfx/cull_face_mode.hpp>
#include <mbgl/gfx/renderable.hpp>
#include <mbgl/gfx/renderer_backend.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/renderer/buckets/fill_bucket.hpp>
#include <mbgl/renderer/image_manager.hpp>
#include <mbgl/renderer/layer_group.hpp>
#include <mbgl/renderer/layers/render_fill_layer.hpp>
#include <mbgl/renderer/paint_parameters.hpp>
#include <mbgl/renderer/render_source.hpp>
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/style/expression/image.hpp>
#include <mbgl/style/layers/fill_layer_impl.hpp>
#include <mbgl/tile/geometry_tile.hpp>
#include <mbgl/tile/tile.hpp>
#include <mbgl/util/intersection_tests.hpp>
#include <mbgl/util/math.hpp>

namespace mbgl {

using namespace style;

namespace {

inline const FillLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
    assert(impl->getTypeInfo() == FillLayer::Impl::staticTypeInfo());
    return static_cast<const FillLayer::Impl&>(*impl);
}

} // namespace

RenderFillLayer::RenderFillLayer(Immutable<style::FillLayer::Impl> _impl)
    : RenderLayer(makeMutable<FillLayerProperties>(std::move(_impl))),
      unevaluated(impl_cast(baseImpl).paint.untransitioned()) {}

RenderFillLayer::~RenderFillLayer() = default;

void RenderFillLayer::transition(const TransitionParameters& parameters) {
    unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}

void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) {
    auto properties = makeMutable<FillLayerProperties>(staticImmutableCast<FillLayer::Impl>(baseImpl),
                                                       parameters.getCrossfadeParameters(),
                                                       unevaluated.evaluate(parameters));
    auto& evaluated = properties->evaluated;

    if (unevaluated.get<style::FillOutlineColor>().isUndefined()) {
        evaluated.get<style::FillOutlineColor>() = evaluated.get<style::FillColor>();
    }

    passes = RenderPass::Translucent;

    if (!(!unevaluated.get<style::FillPattern>().isUndefined() ||
          evaluated.get<style::FillColor>().constantOr(Color()).a < 1.0f ||
          evaluated.get<style::FillOpacity>().constantOr(0) < 1.0f)) {
        // Supply both - evaluated based on opaquePassCutoff in render().
        passes |= RenderPass::Opaque;
    }
    properties->renderPasses = mbgl::underlying_type(passes);
    evaluatedProperties = std::move(properties);
}

bool RenderFillLayer::hasTransition() const {
    return unevaluated.hasTransition();
}

bool RenderFillLayer::hasCrossfade() const {
    return getCrossfade<FillLayerProperties>(evaluatedProperties).t != 1;
}

void RenderFillLayer::render(PaintParameters& parameters) {
    assert(renderTiles);

    if (!parameters.shaders.populate(fillProgram)) return;
    if (!parameters.shaders.populate(fillPatternProgram)) return;
    if (!parameters.shaders.populate(fillOutlineProgram)) return;
    if (!parameters.shaders.populate(fillOutlinePatternProgram)) return;

    if (unevaluated.get<FillPattern>().isUndefined()) {
        parameters.renderTileClippingMasks(renderTiles);
        for (const RenderTile& tile : *renderTiles) {
            const LayerRenderData* renderData = getRenderDataForPass(tile, parameters.pass);
            if (!renderData) {
                continue;
            }
            auto& bucket = static_cast<FillBucket&>(*renderData->bucket);
            const auto& evaluated = getEvaluated<FillLayerProperties>(renderData->layerProperties);

            auto draw = [&](auto& programInstance,
                            const auto& drawMode,
                            const auto& depthMode,
                            const auto& indexBuffer,
                            const auto& segments,
                            auto&& textureBindings) {
                const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());

                const auto allUniformValues = programInstance.computeAllUniformValues(
                    FillProgram::LayoutUniformValues{
                        uniforms::matrix::Value(tile.translatedMatrix(
                            evaluated.get<FillTranslate>(), evaluated.get<FillTranslateAnchor>(), parameters.state)),
                        uniforms::world::Value(parameters.backend.getDefaultRenderable().getSize()),
                    },
                    paintPropertyBinders,
                    evaluated,
                    static_cast<float>(parameters.state.getZoom()));
                const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
                    *bucket.vertexBuffer, paintPropertyBinders, evaluated);

                checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));

                programInstance.draw(parameters.context,
                                     *parameters.renderPass,
                                     drawMode,
                                     depthMode,
                                     parameters.stencilModeForClipping(tile.id),
                                     parameters.colorModeForRenderPass(),
                                     gfx::CullFaceMode::disabled(),
                                     indexBuffer,
                                     segments,
                                     allUniformValues,
                                     allAttributeBindings,
                                     std::forward<decltype(textureBindings)>(textureBindings),
                                     getID());
            };

            auto fillRenderPass = (evaluated.get<FillColor>().constantOr(Color()).a >= 1.0f &&
                                   evaluated.get<FillOpacity>().constantOr(0) >= 1.0f &&
                                   parameters.currentLayer >= parameters.opaquePassCutoff)
                                      ? RenderPass::Opaque
                                      : RenderPass::Translucent;
            if (bucket.triangleIndexBuffer && parameters.pass == fillRenderPass) {
                draw(*fillProgram,
                     gfx::Triangles(),
                     parameters.depthModeForSublayer(1,
                                                     parameters.pass == RenderPass::Opaque
                                                         ? gfx::DepthMaskType::ReadWrite
                                                         : gfx::DepthMaskType::ReadOnly),
                     *bucket.triangleIndexBuffer,
                     bucket.triangleSegments,
                     FillProgram::TextureBindings{});
            }

            if (evaluated.get<FillAntialias>() && parameters.pass == RenderPass::Translucent) {
                draw(*fillOutlineProgram,
                     gfx::Lines{2.0f},
                     parameters.depthModeForSublayer(unevaluated.get<FillOutlineColor>().isUndefined() ? 2 : 0,
                                                     gfx::DepthMaskType::ReadOnly),
                     *bucket.lineIndexBuffer,
                     bucket.lineSegments,
                     FillOutlineProgram::TextureBindings{});
            }
        }
    } else {
        if (parameters.pass != RenderPass::Translucent) {
            return;
        }

        parameters.renderTileClippingMasks(renderTiles);

        for (const RenderTile& tile : *renderTiles) {
            const LayerRenderData* renderData = getRenderDataForPass(tile, parameters.pass);
            if (!renderData) {
                continue;
            }
            auto& bucket = static_cast<FillBucket&>(*renderData->bucket);
            const auto& evaluated = getEvaluated<FillLayerProperties>(renderData->layerProperties);
            const auto& crossfade = getCrossfade<FillLayerProperties>(renderData->layerProperties);

            const auto& fillPatternValue = evaluated.get<FillPattern>().constantOr(Faded<expression::Image>{"", ""});
            std::optional<ImagePosition> patternPosA = tile.getPattern(fillPatternValue.from.id());
            std::optional<ImagePosition> patternPosB = tile.getPattern(fillPatternValue.to.id());

            auto draw = [&](auto& programInstance,
                            const auto& drawMode,
                            const auto& depthMode,
                            const auto& indexBuffer,
                            const auto& segments,
                            auto&& textureBindings) {
                const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
                paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade);

                const auto allUniformValues = programInstance.computeAllUniformValues(
                    FillPatternProgram::layoutUniformValues(
                        tile.translatedMatrix(
                            evaluated.get<FillTranslate>(), evaluated.get<FillTranslateAnchor>(), parameters.state),
                        parameters.backend.getDefaultRenderable().getSize(),
                        tile.getIconAtlasTexture().size,
                        crossfade,
                        tile.id,
                        parameters.state,
                        parameters.pixelRatio),
                    paintPropertyBinders,
                    evaluated,
                    static_cast<float>(parameters.state.getZoom()));
                const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
                    *bucket.vertexBuffer, paintPropertyBinders, evaluated);

                checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));

                programInstance.draw(parameters.context,
                                     *parameters.renderPass,
                                     drawMode,
                                     depthMode,
                                     parameters.stencilModeForClipping(tile.id),
                                     parameters.colorModeForRenderPass(),
                                     gfx::CullFaceMode::disabled(),
                                     indexBuffer,
                                     segments,
                                     allUniformValues,
                                     allAttributeBindings,
                                     std::forward<decltype(textureBindings)>(textureBindings),
                                     getID());
            };

            if (bucket.triangleIndexBuffer) {
                draw(*fillPatternProgram,
                     gfx::Triangles(),
                     parameters.depthModeForSublayer(1, gfx::DepthMaskType::ReadWrite),
                     *bucket.triangleIndexBuffer,
                     bucket.triangleSegments,
                     FillPatternProgram::TextureBindings{
                         textures::image::Value{tile.getIconAtlasTexture().getResource(),
                                                gfx::TextureFilterType::Linear},
                     });
            }
            if (evaluated.get<FillAntialias>() && unevaluated.get<FillOutlineColor>().isUndefined()) {
                draw(*fillOutlinePatternProgram,
                     gfx::Lines{2.0f},
                     parameters.depthModeForSublayer(2, gfx::DepthMaskType::ReadOnly),
                     *bucket.lineIndexBuffer,
                     bucket.lineSegments,
                     FillOutlinePatternProgram::TextureBindings{
                         textures::image::Value{tile.getIconAtlasTexture().getResource(),
                                                gfx::TextureFilterType::Linear},
                     });
            }
        }
    }
}

bool RenderFillLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry,
                                             const GeometryTileFeature& feature,
                                             const float,
                                             const TransformState& transformState,
                                             const float pixelsToTileUnits,
                                             const mat4&,
                                             const FeatureState&) const {
    const auto& evaluated = getEvaluated<FillLayerProperties>(evaluatedProperties);
    auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(queryGeometry,
                                                                        evaluated.get<style::FillTranslate>(),
                                                                        evaluated.get<style::FillTranslateAnchor>(),
                                                                        static_cast<float>(transformState.getBearing()),
                                                                        pixelsToTileUnits);

    return util::polygonIntersectsMultiPolygon(translatedQueryGeometry.value_or(queryGeometry),
                                               feature.getGeometries());
}

void RenderFillLayer::layerRemoved(UniqueChangeRequestVec& changes) {
    // Remove everything
    if (tileLayerGroup) {
        changes.emplace_back(std::make_unique<RemoveLayerGroupRequest>(tileLayerGroup->getLayerIndex()));
        tileLayerGroup.reset();
    }
}

void RenderFillLayer::update(const int32_t layerIndex,
                             gfx::ShaderRegistry& shaders,
                             gfx::Context& context,
                             const TransformState& /*state*/,
                             UniqueChangeRequestVec& changes) {
    std::unique_lock<std::mutex> guard(mutex);

    if (!shader) {
        shader = context.getGenericShader(shaders, "FillShader");
    }

    if (!shader || !renderTiles || renderTiles->empty()) {
        if (tileLayerGroup) {
            stats.tileDrawablesRemoved += tileLayerGroup->getDrawableCount();
            tileLayerGroup->clearDrawables();
        }
        return;
    }

    // Set up a layer group
    if (!tileLayerGroup) {
        tileLayerGroup = context.createTileLayerGroup(layerIndex, /*initialCapacity=*/64);
        if (!tileLayerGroup) {
            return;
        }
        changes.emplace_back(std::make_unique<AddLayerGroupRequest>(tileLayerGroup, /*canReplace=*/true));
    }

    std::unordered_set<OverscaledTileID> newTileIDs(renderTiles->size());
    std::transform(renderTiles->begin(),
                   renderTiles->end(),
                   std::inserter(newTileIDs, newTileIDs.begin()),
                   [](const auto& renderTile) -> OverscaledTileID { return renderTile.get().getOverscaledTileID(); });

    std::unique_ptr<gfx::DrawableBuilder> builder;
    std::vector<gfx::DrawablePtr> newTiles;

    for (const auto renderPass : {RenderPass::Opaque, RenderPass::Translucent}) {
        tileLayerGroup->observeDrawables([&](gfx::UniqueDrawable& drawable) {
            // Has this tile dropped out of the cover set?
            const auto tileID = drawable->getTileID();
            if (tileID && newTileIDs.find(*tileID) == newTileIDs.end()) {
                // remove it
                drawable.reset();
                ++stats.tileDrawablesRemoved;
            }
        });

        if (unevaluated.get<FillPattern>().isUndefined()) {
            // parameters.renderTileClippingMasks(renderTiles);
            for (const RenderTile& tile : *renderTiles) {
                const auto& tileID = tile.getOverscaledTileID();

                auto& tileDrawable = tileLayerGroup->getDrawable(renderPass, tileID);

                const auto removeTile = [&]() {
                    if (tileDrawable) {
                        tileLayerGroup->removeDrawable(renderPass, tileID);
                        ++stats.tileDrawablesRemoved;
                    }
                };

                const LayerRenderData* renderData = getRenderDataForPass(tile, renderPass);
                if (!renderData) {
                    removeTile();
                    continue;
                }

                auto& bucket = static_cast<FillBucket&>(*renderData->bucket);
                const auto& evaluated = getEvaluated<FillLayerProperties>(renderData->layerProperties);
                const auto evalColor = evaluated.get<FillColor>().constantOr(Color());
                const auto fillOpacity = evaluated.get<FillOpacity>().constantOr(0);
                const auto fillColor = evalColor * (fillOpacity > 0.0f ? fillOpacity : 1.0f);

                const auto fillRenderPass = (evalColor.a >= 1.0f && fillOpacity >= 1.0f
                                             /* && parameters.currentLayer >= parameters.opaquePassCutoff*/)
                                                ? RenderPass::Opaque
                                                : RenderPass::Translucent;

                if (fillRenderPass != renderPass) {
                    removeTile();
                    continue;
                }

                if (tileDrawable) {
                    // needed and already present, update?
                    continue;
                }

                if (!builder) {
                    builder = context.createDrawableBuilder("fill");
                    builder->setShader(shader);
                    builder->addTweaker(context.createDrawableTweaker());
                    builder->setColorMode(gfx::DrawableBuilder::ColorMode::PerVertex);
                    builder->setDepthType(gfx::DepthMaskType::ReadWrite);
                    builder->setLayerIndex(layerIndex);
                }

                // tile.translatedMatrix(evaluated.get<FillTranslate>(), evaluated.get<FillTranslateAnchor>(),
                // parameters.state)

                builder->setColor(fillColor);
                builder->setRenderPass(renderPass);

                const std::vector<gfx::VertexVector<gfx::detail::VertexType<gfx::AttributeType<int16_t, 2>>>::Vertex>&
                    verts = bucket.vertices.vector();
                std::vector<std::array<int16_t, 2>> rawVerts(verts.size());
                std::transform(verts.begin(), verts.end(), rawVerts.begin(), [](const auto& x) { return x.a1; });

                for (const auto& seg : bucket.triangleSegments) {
                    builder->addTriangles(rawVerts,
                                          seg.vertexOffset,
                                          seg.vertexLength,
                                          bucket.triangles.vector(),
                                          seg.indexOffset,
                                          seg.indexLength);
                }

                //            evaluated.get<FillTranslate>(),
                //            evaluated.get<FillTranslateAnchor>(),
                //            parameters.stencilModeForClipping(tile.id),
                //            parameters.colorModeForRenderPass(),
                //            gfx::CullFaceMode::disabled(),
                //
                //            const auto isOpaque = (evaluated.get<FillColor>().constantOr(Color()).a >= 1.0f &&
                //                                   evaluated.get<FillOpacity>().constantOr(0) >= 1.0f
                //                                   );// && layerIndex >= parameters.opaquePassCutoff);
                //            const auto fillRenderPass = isOpaque ? RenderPass::Opaque : RenderPass::Translucent;
                //
                //            if (renderPass == fillRenderPass) {
                //            }

                // const auto depthMask = (renderPass == RenderPass::Opaque) ? gfx::DepthMaskType::ReadWrite
                //                                                           : gfx::DepthMaskType::ReadOnly;

                //            const auto depthMode = parameters.depthModeForSublayer(1, depthMask);

                //            if (evaluated.get<FillAntialias>() && parameters.pass == RenderPass::Translucent) {
                //                draw(*fillOutlineProgram,
                //                     gfx::Lines{2.0f},
                //                     parameters.depthModeForSublayer(unevaluated.get<FillOutlineColor>().isUndefined()
                //                     ? 2 : 0,
                //                                                     gfx::DepthMaskType::ReadOnly),
                //                     *bucket.lineIndexBuffer,
                //                     bucket.lineSegments,
                //                     FillOutlineProgram::TextureBindings{});
                //            }

                builder->flush();

                auto newDrawables = builder->clearDrawables();
                if (!newDrawables.empty()) {
                    auto& drawable = newDrawables[0];
                    drawable->setTileID(tileID);

                    // Track it.
                    //tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable));
                    ++stats.tileDrawablesAdded;
                    // Log::Warning(Event::General, "Adding drawable for " + util::toString(tileID) + " total " +
                    // std::to_string(stats.tileDrawablesAdded+1));
                }
            }
        } else {
            //        if (parameters.pass != RenderPass::Translucent) {
            //            return;
            //        }
            //
            //        parameters.renderTileClippingMasks(renderTiles);
            //
            //        for (const RenderTile& tile : *renderTiles) {
            //            const LayerRenderData* renderData = getRenderDataForPass(tile, parameters.pass);
            //            if (!renderData) {
            //                continue;
            //            }
            //            auto& bucket = static_cast<FillBucket&>(*renderData->bucket);
            //            const auto& evaluated = getEvaluated<FillLayerProperties>(renderData->layerProperties);
            //            const auto& crossfade = getCrossfade<FillLayerProperties>(renderData->layerProperties);
            //
            //            const auto& fillPatternValue =
            //            evaluated.get<FillPattern>().constantOr(Faded<expression::Image>{"", ""});
            //            std::optional<ImagePosition> patternPosA = tile.getPattern(fillPatternValue.from.id());
            //            std::optional<ImagePosition> patternPosB = tile.getPattern(fillPatternValue.to.id());
            //
            //            auto draw = [&](auto& programInstance,
            //                            const auto& drawMode,
            //                            const auto& depthMode,
            //                            const auto& indexBuffer,
            //                            const auto& segments,
            //                            auto&& textureBindings) {
            //                const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
            //                paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade);
            //
            //                const auto allUniformValues = programInstance.computeAllUniformValues(
            //                    FillPatternProgram::layoutUniformValues(
            //                        tile.translatedMatrix(
            //                            evaluated.get<FillTranslate>(), evaluated.get<FillTranslateAnchor>(),
            //                            parameters.state),
            //                        parameters.backend.getDefaultRenderable().getSize(),
            //                        tile.getIconAtlasTexture().size,
            //                        crossfade,
            //                        tile.id,
            //                        parameters.state,
            //                        parameters.pixelRatio),
            //                    paintPropertyBinders,
            //                    evaluated,
            //                    static_cast<float>(parameters.state.getZoom()));
            //                const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
            //                    *bucket.vertexBuffer, paintPropertyBinders, evaluated);
            //
            //                checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
            //
            //                programInstance.draw(parameters.context,
            //                                     *parameters.renderPass,
            //                                     drawMode,
            //                                     depthMode,
            //                                     parameters.stencilModeForClipping(tile.id),
            //                                     parameters.colorModeForRenderPass(),
            //                                     gfx::CullFaceMode::disabled(),
            //                                     indexBuffer,
            //                                     segments,
            //                                     allUniformValues,
            //                                     allAttributeBindings,
            //                                     std::forward<decltype(textureBindings)>(textureBindings),
            //                                     getID());
            //            };
            //
            //            if (bucket.triangleIndexBuffer) {
            //                draw(*fillPatternProgram,
            //                     gfx::Triangles(),
            //                     parameters.depthModeForSublayer(1, gfx::DepthMaskType::ReadWrite),
            //                     *bucket.triangleIndexBuffer,
            //                     bucket.triangleSegments,
            //                     FillPatternProgram::TextureBindings{
            //                         textures::image::Value{tile.getIconAtlasTexture().getResource(),
            //                                                gfx::TextureFilterType::Linear},
            //                     });
            //            }
            //            if (evaluated.get<FillAntialias>() && unevaluated.get<FillOutlineColor>().isUndefined()) {
            //                draw(*fillOutlinePatternProgram,
            //                     gfx::Lines{2.0f},
            //                     parameters.depthModeForSublayer(2, gfx::DepthMaskType::ReadOnly),
            //                     *bucket.lineIndexBuffer,
            //                     bucket.lineSegments,
            //                     FillOutlinePatternProgram::TextureBindings{
            //                         textures::image::Value{tile.getIconAtlasTexture().getResource(),
            //                                                gfx::TextureFilterType::Linear},
            //                     });
            //            }
            //        }
        }
    }
}

} // namespace mbgl