// Copyright 2023 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "src/tint/lang/core/ir/transform/bgra8unorm_polyfill.h"

#include <utility>

#include "src/tint/lang/core/ir/builder.h"
#include "src/tint/lang/core/ir/module.h"
#include "src/tint/lang/core/ir/validator.h"
#include "src/tint/lang/core/type/pointer.h"
#include "src/tint/lang/core/type/storage_texture.h"

using namespace tint::core::fluent_types;     // NOLINT
using namespace tint::core::number_suffixes;  // NOLINT

namespace tint::core::ir::transform {

namespace {

/// PIMPL state for the transform.
struct State {
    /// The IR module.
    Module* ir = nullptr;

    /// The IR builder.
    Builder b{*ir};

    /// The type manager.
    core::type::Manager& ty{ir->Types()};

    /// Process the module.
    void Process() {
        // Find module-scope variables that need to be replaced.
        if (ir->root_block) {
            Vector<Instruction*, 4> to_remove;
            for (auto inst : *ir->root_block) {
                auto* var = inst->As<Var>();
                if (!var) {
                    continue;
                }
                auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
                if (!ptr) {
                    continue;
                }
                auto* storage_texture = ptr->StoreType()->As<core::type::StorageTexture>();
                if (storage_texture &&
                    storage_texture->texel_format() == core::TexelFormat::kBgra8Unorm) {
                    ReplaceVar(var, storage_texture);
                    to_remove.Push(var);
                }
            }
            for (auto* remove : to_remove) {
                remove->Destroy();
            }
        }

        // Find function parameters that need to be replaced.
        for (auto* func : ir->functions) {
            for (uint32_t index = 0; index < func->Params().Length(); index++) {
                auto* param = func->Params()[index];
                auto* storage_texture = param->Type()->As<core::type::StorageTexture>();
                if (storage_texture &&
                    storage_texture->texel_format() == core::TexelFormat::kBgra8Unorm) {
                    ReplaceParameter(func, param, index, storage_texture);
                }
            }
        }
    }

    /// Replace a variable declaration with one that uses rgba8unorm instead of bgra8unorm.
    /// @param old_var the variable declaration to replace
    /// @param bgra8 the bgra8unorm texture type
    void ReplaceVar(Var* old_var, const core::type::StorageTexture* bgra8) {
        // Redeclare the variable with a rgba8unorm texel format.
        auto* rgba8 = ty.Get<core::type::StorageTexture>(
            bgra8->dim(), core::TexelFormat::kRgba8Unorm, bgra8->access(), bgra8->type());
        auto* new_var = b.Var(ty.ptr(handle, rgba8));
        auto bp = old_var->BindingPoint();
        new_var->SetBindingPoint(bp->group, bp->binding);
        new_var->InsertBefore(old_var);
        if (auto name = ir->NameOf(old_var)) {
            ir->SetName(new_var, name.NameView());
        }

        // Replace all uses of the old variable with the new one.
        ReplaceUses(old_var->Result(), new_var->Result());
    }

    /// Replace a function parameter with one that uses rgba8unorm instead of bgra8unorm.
    /// @param func the function
    /// @param old_param the function parameter to replace
    /// @param index the index of the function parameter
    /// @param bgra8 the bgra8unorm texture type
    void ReplaceParameter(Function* func,
                          FunctionParam* old_param,
                          uint32_t index,
                          const core::type::StorageTexture* bgra8) {
        // Redeclare the parameter with a rgba8unorm texel format.
        auto* rgba8 = ty.Get<core::type::StorageTexture>(
            bgra8->dim(), core::TexelFormat::kRgba8Unorm, bgra8->access(), bgra8->type());
        auto* new_param = b.FunctionParam(rgba8);
        if (auto name = ir->NameOf(old_param)) {
            ir->SetName(new_param, name.NameView());
        }

        Vector<FunctionParam*, 4> new_params = func->Params();
        new_params[index] = new_param;
        func->SetParams(std::move(new_params));

        // Replace all uses of the old parameter with the new one.
        ReplaceUses(old_param, new_param);
    }

    /// Recursively replace the uses of @p value with @p new_value.
    /// @param old_value the value whose usages should be replaced
    /// @param new_value the value to use instead
    void ReplaceUses(Value* old_value, Value* new_value) {
        old_value->ForEachUse([&](Usage use) {
            tint::Switch(
                use.instruction,
                [&](Load* load) {
                    // Replace load instructions with new ones that have the updated type.
                    auto* new_load = b.Load(new_value);
                    new_load->InsertBefore(load);
                    ReplaceUses(load->Result(), new_load->Result());
                    load->Destroy();
                },
                [&](CoreBuiltinCall* call) {
                    // Replace arguments to builtin functions and add swizzles if necessary.
                    call->SetOperand(use.operand_index, new_value);
                    if (call->Func() == core::Function::kTextureStore) {
                        // Swizzle the value argument of a `textureStore()` builtin.
                        auto* tex = old_value->Type()->As<core::type::StorageTexture>();
                        auto index = core::type::IsTextureArray(tex->dim()) ? 3u : 2u;
                        auto* value = call->Args()[index];
                        auto* swizzle = b.Swizzle(value->Type(), value, Vector{2u, 1u, 0u, 3u});
                        swizzle->InsertBefore(call);
                        call->SetOperand(index, swizzle->Result());
                    } else if (call->Func() == core::Function::kTextureLoad) {
                        // Swizzle the result of a `textureLoad()` builtin.
                        auto* swizzle =
                            b.Swizzle(call->Result()->Type(), nullptr, Vector{2u, 1u, 0u, 3u});
                        call->Result()->ReplaceAllUsesWith(swizzle->Result());
                        swizzle->InsertAfter(call);
                        swizzle->SetOperand(Swizzle::kObjectOperandOffset, call->Result());
                    }
                },
                [&](UserCall* call) {
                    // Just replace arguments to user functions and then stop.
                    call->SetOperand(use.operand_index, new_value);
                },
                [&](Default) {
                    TINT_ICE() << "unhandled instruction " << use.instruction->FriendlyName();
                });
        });
    }
};

}  // namespace

Result<SuccessType, std::string> Bgra8UnormPolyfill(Module* ir) {
    auto result = ValidateAndDumpIfNeeded(*ir, "Bgra8UnormPolyfill transform");
    if (!result) {
        return result;
    }

    State{ir}.Process();

    return Success;
}

}  // namespace tint::core::ir::transform