// Copyright (c) 2019 The Khronos Group Inc.
//
// 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 "gmock/gmock.h"
#include "test/link/linker_fixture.h"

namespace spvtools {
namespace {

using TypeMatch = spvtest::LinkerTest;

// Basic types
#define PartInt(D, N) D(N) " = OpTypeInt 32 0"
#define PartFloat(D, N) D(N) " = OpTypeFloat 32"
#define PartOpaque(D, N) D(N) " = OpTypeOpaque \"bar\""
#define PartSampler(D, N) D(N) " = OpTypeSampler"
#define PartEvent(D, N) D(N) " = OpTypeEvent"
#define PartDeviceEvent(D, N) D(N) " = OpTypeDeviceEvent"
#define PartReserveId(D, N) D(N) " = OpTypeReserveId"
#define PartQueue(D, N) D(N) " = OpTypeQueue"
#define PartPipe(D, N) D(N) " = OpTypePipe ReadWrite"
#define PartPipeStorage(D, N) D(N) " = OpTypePipeStorage"
#define PartNamedBarrier(D, N) D(N) " = OpTypeNamedBarrier"

// Compound types
#define PartVector(DR, DA, N, T) DR(N) " = OpTypeVector " DA(T) " 3"
#define PartMatrix(DR, DA, N, T) DR(N) " = OpTypeMatrix " DA(T) " 4"
#define PartImage(DR, DA, N, T) \
  DR(N) " = OpTypeImage " DA(T) " 2D 0 0 0 0 Rgba32f"
#define PartSampledImage(DR, DA, N, T) DR(N) " = OpTypeSampledImage " DA(T)
#define PartArray(DR, DA, N, T) DR(N) " = OpTypeArray " DA(T) " " DA(const)
#define PartRuntimeArray(DR, DA, N, T) DR(N) " = OpTypeRuntimeArray " DA(T)
#define PartStruct(DR, DA, N, T) DR(N) " = OpTypeStruct " DA(T) " " DA(T)
#define PartPointer(DR, DA, N, T) DR(N) " = OpTypePointer Workgroup " DA(T)
#define PartFunction(DR, DA, N, T) DR(N) " = OpTypeFunction " DA(T) " " DA(T)

#define CheckDecoRes(S) "[[" #S ":%\\w+]]"
#define CheckDecoArg(S) "[[" #S "]]"
#define InstDeco(S) "%" #S

#define MatchPart1(F, N) \
  "; CHECK: " Part##F(CheckDecoRes, N) "\n" Part##F(InstDeco, N) "\n"
#define MatchPart2(F, N, T)                                           \
  "; CHECK: " Part##F(CheckDecoRes, CheckDecoArg, N, T) "\n" Part##F( \
      InstDeco, InstDeco, N, T) "\n"

#define MatchF(N, CODE)                                         \
  TEST_F(TypeMatch, N) {                                        \
    const std::string base =                                    \
        "OpCapability Linkage\n"                                \
        "OpCapability NamedBarrier\n"                           \
        "OpCapability PipeStorage\n"                            \
        "OpCapability Pipes\n"                                  \
        "OpCapability DeviceEnqueue\n"                          \
        "OpCapability Kernel\n"                                 \
        "OpCapability Shader\n"                                 \
        "OpCapability Addresses\n"                              \
        "OpDecorate %var LinkageAttributes \"foo\" "            \
        "{Import,Export}\n"                                     \
        "; CHECK: [[baseint:%\\w+]] = OpTypeInt 32 1\n"         \
        "%baseint = OpTypeInt 32 1\n"                           \
        "; CHECK: [[const:%\\w+]] = OpConstant [[baseint]] 3\n" \
        "%const = OpConstant %baseint 3\n" CODE                 \
        "; CHECK: OpVariable [[type]] Uniform\n"                \
        "%var = OpVariable %type Uniform";                      \
    ExpandAndMatch(base);                                       \
  }

#define Match1(T) MatchF(Type##T, MatchPart1(T, type))
#define Match2(T, A) \
  MatchF(T##OfType##A, MatchPart1(A, a) MatchPart2(T, type, a))
#define Match3(T, A, B)   \
  MatchF(T##Of##A##Of##B, \
         MatchPart1(B, b) MatchPart2(A, a, b) MatchPart2(T, type, a))

// Basic types
Match1(Int);
Match1(Float);
Match1(Opaque);
Match1(Sampler);
Match1(Event);
Match1(DeviceEvent);
Match1(ReserveId);
Match1(Queue);
Match1(Pipe);
Match1(PipeStorage);
Match1(NamedBarrier);

// Simpler (restricted) compound types
Match2(Vector, Float);
Match3(Matrix, Vector, Float);
Match2(Image, Float);

// Unrestricted compound types
#define MatchCompounds1(A) \
  Match2(RuntimeArray, A); \
  Match2(Struct, A);       \
  Match2(Pointer, A);      \
  Match2(Function, A);     \
  Match2(Array, A);
#define MatchCompounds2(A, B) \
  Match3(RuntimeArray, A, B); \
  Match3(Struct, A, B);       \
  Match3(Pointer, A, B);      \
  Match3(Function, A, B);     \
  Match3(Array, A, B);

MatchCompounds1(Float);
MatchCompounds2(Array, Float);
MatchCompounds2(RuntimeArray, Float);
MatchCompounds2(Struct, Float);
MatchCompounds2(Pointer, Float);
MatchCompounds2(Function, Float);

// ForwardPointer tests, which don't fit into the previous mold
#define MatchFpF(N, CODE)                                             \
  MatchF(N,                                                           \
         "; CHECK: OpTypeForwardPointer [[type:%\\w+]] Workgroup\n"   \
         "OpTypeForwardPointer %type Workgroup\n" CODE                \
         "; CHECK: [[type]] = OpTypePointer Workgroup [[realtype]]\n" \
         "%type = OpTypePointer Workgroup %realtype\n")
#define MatchFp1(T) MatchFpF(ForwardPointerOf##T, MatchPart1(T, realtype))
#define MatchFp2(T, A) \
  MatchFpF(ForwardPointerOf##T, MatchPart1(A, a) MatchPart2(T, realtype, a))

MatchFp1(Float);
MatchFp2(Array, Float);
MatchFp2(RuntimeArray, Float);
MatchFp2(Struct, Float);
MatchFp2(Function, Float);

}  // namespace
}  // namespace spvtools