// Copyright 2022 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/sem/materialize.h"

#include "src/tint/resolver/resolver.h"
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/test_helper.h"

#include "gmock/gmock.h"

using namespace tint::number_suffixes;  // NOLINT

namespace tint::resolver {
namespace {

using AFloatV = builder::vec<3, AFloat>;
using AFloatM = builder::mat<3, 2, AFloat>;
using AIntV = builder::vec<3, AInt>;
using f32V = builder::vec<3, f32>;
using f16V = builder::vec<3, f16>;
using i32V = builder::vec<3, i32>;
using u32V = builder::vec<3, u32>;
using f32M = builder::mat<3, 2, f32>;

////////////////////////////////////////////////////////////////////////////////
// MaterializeTests
////////////////////////////////////////////////////////////////////////////////
namespace MaterializeTests {

// How should the materialization occur?
enum class Method {
    // var a : T = literal;
    kVar,

    // let a : T = literal;
    kLet,

    // fn F(v : T) {}
    // fn x() {
    //   F(literal);
    // }
    kFnArg,

    // min(target_expr, literal);
    kBuiltinArg,

    // fn F() : T {
    //   return literal;
    // }
    kReturn,

    // array<T, 1>(literal);
    kArray,

    // struct S {
    //   v : T
    // };
    // fn x() {
    //   _ = S(literal)
    // }
    kStruct,

    // target_expr + literal
    kBinaryOp,

    // switch (literal) {
    //   case target_expr: {}
    //   default: {}
    // }
    kSwitchCond,

    // switch (target_expr) {
    //   case literal: {}
    //   default: {}
    // }
    kSwitchCase,

    // switch (literal) {
    //   case 123: {}
    //   case target_expr: {}
    //   default: {}
    // }
    kSwitchCondWithAbstractCase,

    // switch (target_expr) {
    //   case 123: {}
    //   case literal: {}
    //   default: {}
    // }
    kSwitchCaseWithAbstractCase,
};

static std::ostream& operator<<(std::ostream& o, Method m) {
    switch (m) {
        case Method::kVar:
            return o << "var";
        case Method::kLet:
            return o << "let";
        case Method::kFnArg:
            return o << "fn-arg";
        case Method::kBuiltinArg:
            return o << "builtin-arg";
        case Method::kReturn:
            return o << "return";
        case Method::kArray:
            return o << "array";
        case Method::kStruct:
            return o << "struct";
        case Method::kBinaryOp:
            return o << "binary-op";
        case Method::kSwitchCond:
            return o << "switch-cond";
        case Method::kSwitchCase:
            return o << "switch-case";
        case Method::kSwitchCondWithAbstractCase:
            return o << "switch-cond-with-abstract";
        case Method::kSwitchCaseWithAbstractCase:
            return o << "switch-case-with-abstract";
    }
    return o << "<unknown>";
}

struct Data {
    std::string target_type_name;
    std::string target_element_type_name;
    builder::ast_type_func_ptr target_ast_ty;
    builder::sem_type_func_ptr target_sem_ty;
    builder::ast_expr_func_ptr target_expr;
    std::string source_type_name;
    builder::ast_expr_func_ptr source_builder;
    std::variant<AInt, AFloat> materialized_value;
    double literal_value;
};

template <typename TARGET_TYPE, typename SOURCE_TYPE, typename MATERIALIZED_TYPE>
Data Types(MATERIALIZED_TYPE materialized_value, double literal_value) {
    using TargetDataType = builder::DataType<TARGET_TYPE>;
    using SourceDataType = builder::DataType<SOURCE_TYPE>;
    using TargetElementDataType = builder::DataType<typename TargetDataType::ElementType>;
    return {
        TargetDataType::Name(),         // target_type_name
        TargetElementDataType::Name(),  // target_element_type_name
        TargetDataType::AST,            // target_ast_ty
        TargetDataType::Sem,            // target_sem_ty
        TargetDataType::Expr,           // target_expr
        SourceDataType::Name(),         // literal_type_name
        SourceDataType::Expr,           // literal_builder
        materialized_value,
        literal_value,
    };
}

template <typename TARGET_TYPE, typename SOURCE_TYPE>
Data Types() {
    using TargetDataType = builder::DataType<TARGET_TYPE>;
    using SourceDataType = builder::DataType<SOURCE_TYPE>;
    using TargetElementDataType = builder::DataType<typename TargetDataType::ElementType>;
    return {
        TargetDataType::Name(),         // target_type_name
        TargetElementDataType::Name(),  // target_element_type_name
        TargetDataType::AST,            // target_ast_ty
        TargetDataType::Sem,            // target_sem_ty
        TargetDataType::Expr,           // target_expr
        SourceDataType::Name(),         // literal_type_name
        SourceDataType::Expr,           // literal_builder
        0_a,
        0.0,
    };
}

static std::ostream& operator<<(std::ostream& o, const Data& c) {
    auto print_value = [&](auto&& v) { o << v; };
    o << "[" << c.target_type_name << " <- " << c.source_type_name << "] [";
    std::visit(print_value, c.materialized_value);
    o << " <- " << c.literal_value << "]";
    return o;
}

enum class Expectation {
    kMaterialize,
    kNoMaterialize,
    kInvalidCast,
    kValueCannotBeRepresented,
};

static std::ostream& operator<<(std::ostream& o, Expectation m) {
    switch (m) {
        case Expectation::kMaterialize:
            return o << "pass";
        case Expectation::kNoMaterialize:
            return o << "no-materialize";
        case Expectation::kInvalidCast:
            return o << "invalid-cast";
        case Expectation::kValueCannotBeRepresented:
            return o << "value too low or high";
    }
    return o << "<unknown>";
}

using MaterializeAbstractNumeric =
    resolver::ResolverTestWithParam<std::tuple<Expectation, Method, Data>>;

TEST_P(MaterializeAbstractNumeric, Test) {
    // Once F16 is properly supported, we'll need to enable this:
    // Enable(ast::Extension::kF16);

    const auto& param = GetParam();
    const auto& expectation = std::get<0>(param);
    const auto& method = std::get<1>(param);
    const auto& data = std::get<2>(param);

    auto target_ty = [&] { return data.target_ast_ty(*this); };
    auto target_expr = [&] { return data.target_expr(*this, 42); };
    auto* literal = data.source_builder(*this, data.literal_value);
    switch (method) {
        case Method::kVar:
            WrapInFunction(Decl(Var("a", target_ty(), literal)));
            break;
        case Method::kLet:
            WrapInFunction(Decl(Let("a", target_ty(), literal)));
            break;
        case Method::kFnArg:
            Func("F", {Param("P", target_ty())}, ty.void_(), {});
            WrapInFunction(CallStmt(Call("F", literal)));
            break;
        case Method::kBuiltinArg:
            WrapInFunction(CallStmt(Call("min", target_expr(), literal)));
            break;
        case Method::kReturn:
            Func("F", {}, target_ty(), {Return(literal)});
            break;
        case Method::kArray:
            WrapInFunction(Construct(ty.array(target_ty(), 1_i), literal));
            break;
        case Method::kStruct:
            Structure("S", {Member("v", target_ty())});
            WrapInFunction(Construct(ty.type_name("S"), literal));
            break;
        case Method::kBinaryOp:
            WrapInFunction(Add(target_expr(), literal));
            break;
        case Method::kSwitchCond:
            WrapInFunction(Switch(literal,                                               //
                                  Case(target_expr()->As<ast::IntLiteralExpression>()),  //
                                  DefaultCase()));
            break;
        case Method::kSwitchCase:
            WrapInFunction(Switch(target_expr(),                                   //
                                  Case(literal->As<ast::IntLiteralExpression>()),  //
                                  DefaultCase()));
            break;
        case Method::kSwitchCondWithAbstractCase:
            WrapInFunction(Switch(literal,                                               //
                                  Case(Expr(123_a)),                                     //
                                  Case(target_expr()->As<ast::IntLiteralExpression>()),  //
                                  DefaultCase()));
            break;
        case Method::kSwitchCaseWithAbstractCase:
            WrapInFunction(Switch(target_expr(),                                   //
                                  Case(Expr(123_a)),                               //
                                  Case(literal->As<ast::IntLiteralExpression>()),  //
                                  DefaultCase()));
            break;
    }

    auto check_types_and_values = [&](const sem::Expression* expr) {
        auto* target_sem_ty = data.target_sem_ty(*this);

        EXPECT_TYPE(expr->Type(), target_sem_ty);
        EXPECT_TYPE(expr->ConstantValue().Type(), target_sem_ty);

        uint32_t num_elems = 0;
        const sem::Type* target_sem_el_ty = sem::Type::ElementOf(target_sem_ty, &num_elems);
        EXPECT_TYPE(expr->ConstantValue().ElementType(), target_sem_el_ty);
        expr->ConstantValue().WithElements([&](auto&& vec) {
            using VEC_TY = std::decay_t<decltype(vec)>;
            using EL_TY = typename VEC_TY::value_type;
            ASSERT_TRUE(std::holds_alternative<EL_TY>(data.materialized_value));
            VEC_TY expected(num_elems, std::get<EL_TY>(data.materialized_value));
            EXPECT_EQ(vec, expected);
        });
    };

    switch (expectation) {
        case Expectation::kMaterialize: {
            ASSERT_TRUE(r()->Resolve()) << r()->error();
            auto* materialize = Sem().Get<sem::Materialize>(literal);
            ASSERT_NE(materialize, nullptr);
            check_types_and_values(materialize);
            break;
        }
        case Expectation::kNoMaterialize: {
            ASSERT_TRUE(r()->Resolve()) << r()->error();
            auto* sem = Sem().Get(literal);
            ASSERT_NE(sem, nullptr);
            EXPECT_FALSE(sem->Is<sem::Materialize>());
            check_types_and_values(sem);
            break;
        }
        case Expectation::kInvalidCast: {
            ASSERT_FALSE(r()->Resolve());
            std::string expect;
            switch (method) {
                case Method::kBuiltinArg:
                    expect = "error: no matching call to min(" + data.target_type_name + ", " +
                             data.source_type_name + ")";
                    break;
                case Method::kBinaryOp:
                    expect = "error: no matching overload for operator + (" +
                             data.target_type_name + ", " + data.source_type_name + ")";
                    break;
                default:
                    expect = "error: cannot convert value of type '" + data.source_type_name +
                             "' to type '" + data.target_type_name + "'";
                    break;
            }
            EXPECT_THAT(r()->error(), testing::StartsWith(expect));
            break;
        }
        case Expectation::kValueCannotBeRepresented:
            ASSERT_FALSE(r()->Resolve());
            EXPECT_THAT(r()->error(), testing::HasSubstr("cannot be represented as '" +
                                                         data.target_element_type_name + "'"));
            break;
    }
}

/// Methods that support scalar materialization
constexpr Method kScalarMethods[] = {Method::kLet,         //
                                     Method::kVar,         //
                                     Method::kFnArg,       //
                                     Method::kBuiltinArg,  //
                                     Method::kReturn,      //
                                     Method::kArray,       //
                                     Method::kStruct,      //
                                     Method::kBinaryOp};

/// Methods that support vector materialization
constexpr Method kVectorMethods[] = {Method::kLet,         //
                                     Method::kVar,         //
                                     Method::kFnArg,       //
                                     Method::kBuiltinArg,  //
                                     Method::kReturn,      //
                                     Method::kArray,       //
                                     Method::kStruct,      //
                                     Method::kBinaryOp};

/// Methods that support matrix materialization
constexpr Method kMatrixMethods[] = {Method::kLet,     //
                                     Method::kVar,     //
                                     Method::kFnArg,   //
                                     Method::kReturn,  //
                                     Method::kArray,   //
                                     Method::kStruct,  //
                                     Method::kBinaryOp};

/// Methods that support materialization for switch cases
constexpr Method kSwitchMethods[] = {Method::kSwitchCond,                  //
                                     Method::kSwitchCase,                  //
                                     Method::kSwitchCondWithAbstractCase,  //
                                     Method::kSwitchCaseWithAbstractCase};

constexpr double kMaxF32 = static_cast<double>(f32::kHighest);
constexpr double kPiF64 = 3.141592653589793;
constexpr double kPiF32 = 3.1415927410125732;  // kPiF64 quantized to f32

// (2^-127)×(1+(0xfffffffffffff÷0x10000000000000))
constexpr double kTooSmallF32 = 1.1754943508222874e-38;

INSTANTIATE_TEST_SUITE_P(
    MaterializeScalar,
    MaterializeAbstractNumeric,                                                       //
    testing::Combine(testing::Values(Expectation::kMaterialize),                      //
                     testing::ValuesIn(kScalarMethods),                               //
                     testing::Values(Types<i32, AInt>(0_a, 0.0),                      //
                                     Types<i32, AInt>(2147483647_a, 2147483647.0),    //
                                     Types<i32, AInt>(-2147483648_a, -2147483648.0),  //
                                     Types<u32, AInt>(0_a, 0.0),                      //
                                     Types<u32, AInt>(4294967295_a, 4294967295.0),    //
                                     Types<f32, AFloat>(0.0_a, 0.0),                  //
                                     Types<f32, AFloat>(AFloat(kMaxF32), kMaxF32),    //
                                     Types<f32, AFloat>(AFloat(-kMaxF32), -kMaxF32),  //
                                     Types<f32, AFloat>(AFloat(kPiF32), kPiF64),      //
                                     Types<f32, AFloat>(0.0_a, kTooSmallF32),         //
                                     Types<f32, AFloat>(-0.0_a, -kTooSmallF32)        //
                                     /* Types<f16, AFloat>(1.0_a), */                 //
                                     /* Types<f16, AFloat>(1.0_a), */)));

INSTANTIATE_TEST_SUITE_P(
    MaterializeVector,
    MaterializeAbstractNumeric,                                                         //
    testing::Combine(testing::Values(Expectation::kMaterialize),                        //
                     testing::ValuesIn(kVectorMethods),                                 //
                     testing::Values(Types<i32V, AIntV>(0_a, 0.0),                      //
                                     Types<i32V, AIntV>(2147483647_a, 2147483647.0),    //
                                     Types<i32V, AIntV>(-2147483648_a, -2147483648.0),  //
                                     Types<u32V, AIntV>(0_a, 0.0),                      //
                                     Types<u32V, AIntV>(4294967295_a, 4294967295.0),    //
                                     Types<f32V, AFloatV>(0.0_a, 0.0),                  //
                                     Types<f32V, AFloatV>(AFloat(kMaxF32), kMaxF32),    //
                                     Types<f32V, AFloatV>(AFloat(-kMaxF32), -kMaxF32),  //
                                     Types<f32V, AFloatV>(AFloat(kPiF32), kPiF64),      //
                                     Types<f32V, AFloatV>(0.0_a, kTooSmallF32),         //
                                     Types<f32V, AFloatV>(-0.0_a, -kTooSmallF32)        //
                                     /* Types<f16V, AFloatV>(1.0_a), */                 //
                                     /* Types<f16V, AFloatV>(1.0_a), */)));

INSTANTIATE_TEST_SUITE_P(
    MaterializeMatrix,
    MaterializeAbstractNumeric,                                                         //
    testing::Combine(testing::Values(Expectation::kMaterialize),                        //
                     testing::ValuesIn(kMatrixMethods),                                 //
                     testing::Values(Types<f32M, AFloatM>(0.0_a, 0.0),                  //
                                     Types<f32M, AFloatM>(AFloat(kMaxF32), kMaxF32),    //
                                     Types<f32M, AFloatM>(AFloat(-kMaxF32), -kMaxF32),  //
                                     Types<f32M, AFloatM>(AFloat(kPiF32), kPiF64),      //
                                     Types<f32M, AFloatM>(0.0_a, kTooSmallF32),         //
                                     Types<f32M, AFloatM>(-0.0_a, -kTooSmallF32)        //
                                     /* Types<f16V, AFloatM>(1.0_a), */                 //
                                     )));

INSTANTIATE_TEST_SUITE_P(
    MaterializeSwitch,
    MaterializeAbstractNumeric,                                                       //
    testing::Combine(testing::Values(Expectation::kMaterialize),                      //
                     testing::ValuesIn(kSwitchMethods),                               //
                     testing::Values(Types<i32, AInt>(0_a, 0.0),                      //
                                     Types<i32, AInt>(2147483647_a, 2147483647.0),    //
                                     Types<i32, AInt>(-2147483648_a, -2147483648.0),  //
                                     Types<u32, AInt>(0_a, 0.0),                      //
                                     Types<u32, AInt>(4294967295_a, 4294967295.0))));

// TODO(crbug.com/tint/1504): Enable once we have abstract overloads of builtins / binary ops.
INSTANTIATE_TEST_SUITE_P(DISABLED_NoMaterialize,
                         MaterializeAbstractNumeric,                                     //
                         testing::Combine(testing::Values(Expectation::kNoMaterialize),  //
                                          testing::Values(Method::kBuiltinArg,           //
                                                          Method::kBinaryOp),            //
                                          testing::Values(Types<AInt, AInt>(),           //
                                                          Types<AFloat, AFloat>(),       //
                                                          Types<AIntV, AIntV>(),         //
                                                          Types<AFloatV, AFloatV>(),     //
                                                          Types<AFloatM, AFloatM>())));
INSTANTIATE_TEST_SUITE_P(InvalidCast,
                         MaterializeAbstractNumeric,                                   //
                         testing::Combine(testing::Values(Expectation::kInvalidCast),  //
                                          testing::ValuesIn(kScalarMethods),           //
                                          testing::Values(Types<i32, AFloat>(),        //
                                                          Types<u32, AFloat>(),        //
                                                          Types<i32V, AFloatV>(),      //
                                                          Types<u32V, AFloatV>())));

INSTANTIATE_TEST_SUITE_P(
    ScalarValueCannotBeRepresented,
    MaterializeAbstractNumeric,                                                //
    testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented),  //
                     testing::ValuesIn(kScalarMethods),                        //
                     testing::Values(Types<i32, AInt>(0_a, 2147483648.0),      //
                                     Types<i32, AInt>(0_a, -2147483649.0),     //
                                     Types<u32, AInt>(0_a, 4294967296),        //
                                     Types<u32, AInt>(0_a, -1.0),              //
                                     Types<f32, AFloat>(0.0_a, 3.5e+38),       //
                                     Types<f32, AFloat>(0.0_a, -3.5e+38)       //
                                     /* Types<f16, AFloat>(), */               //
                                     /* Types<f16, AFloat>(), */)));

INSTANTIATE_TEST_SUITE_P(
    VectorValueCannotBeRepresented,
    MaterializeAbstractNumeric,                                                //
    testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented),  //
                     testing::ValuesIn(kVectorMethods),                        //
                     testing::Values(Types<i32V, AIntV>(0_a, 2147483648.0),    //
                                     Types<i32V, AIntV>(0_a, -2147483649.0),   //
                                     Types<u32V, AIntV>(0_a, 4294967296),      //
                                     Types<u32V, AIntV>(0_a, -1.0),            //
                                     Types<f32V, AFloatV>(0.0_a, 3.5e+38),     //
                                     Types<f32V, AFloatV>(0.0_a, -3.5e+38)     //
                                     /* Types<f16V, AFloatV>(), */             //
                                     /* Types<f16V, AFloatV>(), */)));

INSTANTIATE_TEST_SUITE_P(
    MatrixValueCannotBeRepresented,
    MaterializeAbstractNumeric,                                                //
    testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented),  //
                     testing::ValuesIn(kMatrixMethods),                        //
                     testing::Values(Types<f32M, AFloatM>(0.0_a, 3.5e+38),     //
                                     Types<f32M, AFloatM>(0.0_a, -3.5e+38)     //
                                     /* Types<f16M, AFloatM>(), */             //
                                     /* Types<f16M, AFloatM>(), */)));

}  // namespace MaterializeTests

}  // namespace
}  // namespace tint::resolver