// Copyright 2020 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.

#ifndef SRC_TINT_AST_BUILTIN_TEXTURE_HELPER_TEST_H_
#define SRC_TINT_AST_BUILTIN_TEXTURE_HELPER_TEST_H_

#include <vector>

#include "src/tint/ast/access.h"
#include "src/tint/program_builder.h"
#include "src/tint/sem/storage_texture.h"

namespace tint::ast::builtin::test {

enum class TextureKind {
  kRegular,
  kDepth,
  kDepthMultisampled,
  kMultisampled,
  kStorage
};
enum class TextureDataType { kF32, kU32, kI32 };

std::ostream& operator<<(std::ostream& out, const TextureKind& kind);
std::ostream& operator<<(std::ostream& out, const TextureDataType& ty);

/// Non-exhaustive list of valid texture overloads
enum class ValidTextureOverload {
  kDimensions1d,
  kDimensions2d,
  kDimensions2dLevel,
  kDimensions2dArray,
  kDimensions2dArrayLevel,
  kDimensions3d,
  kDimensions3dLevel,
  kDimensionsCube,
  kDimensionsCubeLevel,
  kDimensionsCubeArray,
  kDimensionsCubeArrayLevel,
  kDimensionsMultisampled2d,
  kDimensionsDepth2d,
  kDimensionsDepth2dLevel,
  kDimensionsDepth2dArray,
  kDimensionsDepth2dArrayLevel,
  kDimensionsDepthCube,
  kDimensionsDepthCubeLevel,
  kDimensionsDepthCubeArray,
  kDimensionsDepthCubeArrayLevel,
  kDimensionsDepthMultisampled2d,
  kDimensionsStorageWO1d,
  kDimensionsStorageWO2d,
  kDimensionsStorageWO2dArray,
  kDimensionsStorageWO3d,
  kGather2dF32,
  kGather2dOffsetF32,
  kGather2dArrayF32,
  kGather2dArrayOffsetF32,
  kGatherCubeF32,
  kGatherCubeArrayF32,
  kGatherDepth2dF32,
  kGatherDepth2dOffsetF32,
  kGatherDepth2dArrayF32,
  kGatherDepth2dArrayOffsetF32,
  kGatherDepthCubeF32,
  kGatherDepthCubeArrayF32,
  kGatherCompareDepth2dF32,
  kGatherCompareDepth2dOffsetF32,
  kGatherCompareDepth2dArrayF32,
  kGatherCompareDepth2dArrayOffsetF32,
  kGatherCompareDepthCubeF32,
  kGatherCompareDepthCubeArrayF32,
  kNumLayers2dArray,
  kNumLayersCubeArray,
  kNumLayersDepth2dArray,
  kNumLayersDepthCubeArray,
  kNumLayersStorageWO2dArray,
  kNumLevels2d,
  kNumLevels2dArray,
  kNumLevels3d,
  kNumLevelsCube,
  kNumLevelsCubeArray,
  kNumLevelsDepth2d,
  kNumLevelsDepth2dArray,
  kNumLevelsDepthCube,
  kNumLevelsDepthCubeArray,
  kNumSamplesMultisampled2d,
  kNumSamplesDepthMultisampled2d,
  kSample1dF32,
  kSample2dF32,
  kSample2dOffsetF32,
  kSample2dArrayF32,
  kSample2dArrayOffsetF32,
  kSample3dF32,
  kSample3dOffsetF32,
  kSampleCubeF32,
  kSampleCubeArrayF32,
  kSampleDepth2dF32,
  kSampleDepth2dOffsetF32,
  kSampleDepth2dArrayF32,
  kSampleDepth2dArrayOffsetF32,
  kSampleDepthCubeF32,
  kSampleDepthCubeArrayF32,
  kSampleBias2dF32,
  kSampleBias2dOffsetF32,
  kSampleBias2dArrayF32,
  kSampleBias2dArrayOffsetF32,
  kSampleBias3dF32,
  kSampleBias3dOffsetF32,
  kSampleBiasCubeF32,
  kSampleBiasCubeArrayF32,
  kSampleLevel2dF32,
  kSampleLevel2dOffsetF32,
  kSampleLevel2dArrayF32,
  kSampleLevel2dArrayOffsetF32,
  kSampleLevel3dF32,
  kSampleLevel3dOffsetF32,
  kSampleLevelCubeF32,
  kSampleLevelCubeArrayF32,
  kSampleLevelDepth2dF32,
  kSampleLevelDepth2dOffsetF32,
  kSampleLevelDepth2dArrayF32,
  kSampleLevelDepth2dArrayOffsetF32,
  kSampleLevelDepthCubeF32,
  kSampleLevelDepthCubeArrayF32,
  kSampleGrad2dF32,
  kSampleGrad2dOffsetF32,
  kSampleGrad2dArrayF32,
  kSampleGrad2dArrayOffsetF32,
  kSampleGrad3dF32,
  kSampleGrad3dOffsetF32,
  kSampleGradCubeF32,
  kSampleGradCubeArrayF32,
  kSampleCompareDepth2dF32,
  kSampleCompareDepth2dOffsetF32,
  kSampleCompareDepth2dArrayF32,
  kSampleCompareDepth2dArrayOffsetF32,
  kSampleCompareDepthCubeF32,
  kSampleCompareDepthCubeArrayF32,
  kSampleCompareLevelDepth2dF32,
  kSampleCompareLevelDepth2dOffsetF32,
  kSampleCompareLevelDepth2dArrayF32,
  kSampleCompareLevelDepth2dArrayOffsetF32,
  kSampleCompareLevelDepthCubeF32,
  kSampleCompareLevelDepthCubeArrayF32,
  kLoad1dLevelF32,
  kLoad1dLevelU32,
  kLoad1dLevelI32,
  kLoad2dLevelF32,
  kLoad2dLevelU32,
  kLoad2dLevelI32,
  kLoad2dArrayLevelF32,
  kLoad2dArrayLevelU32,
  kLoad2dArrayLevelI32,
  kLoad3dLevelF32,
  kLoad3dLevelU32,
  kLoad3dLevelI32,
  kLoadMultisampled2dF32,
  kLoadMultisampled2dU32,
  kLoadMultisampled2dI32,
  kLoadDepth2dLevelF32,
  kLoadDepth2dArrayLevelF32,
  kLoadDepthMultisampled2dF32,
  kStoreWO1dRgba32float,       // Not permutated for all texel formats
  kStoreWO2dRgba32float,       // Not permutated for all texel formats
  kStoreWO2dArrayRgba32float,  // Not permutated for all texel formats
  kStoreWO3dRgba32float,       // Not permutated for all texel formats
};

/// @param texture_overload the ValidTextureOverload
/// @returns true if the ValidTextureOverload builtin returns no value.
bool ReturnsVoid(ValidTextureOverload texture_overload);

/// Describes a texture builtin overload
struct TextureOverloadCase {
  /// Constructor for textureSample...() functions
  TextureOverloadCase(ValidTextureOverload,
                      const char*,
                      TextureKind,
                      ast::SamplerKind,
                      ast::TextureDimension,
                      TextureDataType,
                      const char*,
                      std::function<ExpressionList(ProgramBuilder*)>);
  /// Constructor for textureLoad() functions with non-storage textures
  TextureOverloadCase(ValidTextureOverload,
                      const char*,
                      TextureKind,
                      ast::TextureDimension,
                      TextureDataType,
                      const char*,
                      std::function<ExpressionList(ProgramBuilder*)>);
  /// Constructor for textureLoad() with storage textures
  TextureOverloadCase(ValidTextureOverload,
                      const char*,
                      Access,
                      ast::TexelFormat,
                      ast::TextureDimension,
                      TextureDataType,
                      const char*,
                      std::function<ExpressionList(ProgramBuilder*)>);
  /// Copy constructor
  TextureOverloadCase(const TextureOverloadCase&);
  /// Destructor
  ~TextureOverloadCase();

  /// @return a vector containing a large number (non-exhaustive) of valid
  /// texture overloads.
  static std::vector<TextureOverloadCase> ValidCases();

  /// @param builder the AST builder used for the test
  /// @returns the vector component type of the texture function return value
  const ast::Type* BuildResultVectorComponentType(
      ProgramBuilder* builder) const;
  /// @param builder the AST builder used for the test
  /// @returns a variable holding the test texture, automatically registered as
  /// a global variable.
  const ast::Variable* BuildTextureVariable(ProgramBuilder* builder) const;
  /// @param builder the AST builder used for the test
  /// @returns a Variable holding the test sampler, automatically registered as
  /// a global variable.
  const ast::Variable* BuildSamplerVariable(ProgramBuilder* builder) const;

  /// The enumerator for this overload
  const ValidTextureOverload overload;
  /// A human readable description of the overload
  const char* const description;
  /// The texture kind for the texture parameter
  const TextureKind texture_kind;
  /// The sampler kind for the sampler parameter
  /// Used only when texture_kind is not kStorage
  ast::SamplerKind const sampler_kind = ast::SamplerKind::kSampler;
  /// The access control for the storage texture
  /// Used only when texture_kind is kStorage
  Access const access = Access::kReadWrite;
  /// The image format for the storage texture
  /// Used only when texture_kind is kStorage
  ast::TexelFormat const texel_format = ast::TexelFormat::kNone;
  /// The dimensions of the texture parameter
  ast::TextureDimension const texture_dimension;
  /// The data type of the texture parameter
  const TextureDataType texture_data_type;
  /// Name of the function. e.g. `textureSample`, `textureSampleGrad`, etc
  const char* const function;
  /// A function that builds the AST arguments for the overload
  std::function<ExpressionList(ProgramBuilder*)> const args;
};

std::ostream& operator<<(std::ostream& out, const TextureOverloadCase& data);

}  // namespace tint::ast::builtin::test

#endif  // SRC_TINT_AST_BUILTIN_TEXTURE_HELPER_TEST_H_