// Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
//
// 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 "glog/logging.h"
#include "gtest/gtest.h"
#include "paddle/phi/api/include/api.h"
#include "paddle/phi/api/include/tensor.h"
#include "paddle/phi/common/data_type.h"
#include "paddle/phi/core/kernel_registry.h"
#include "paddle/phi/core/selected_rows.h"

PD_DECLARE_KERNEL(empty, CPU, ALL_LAYOUT);

#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
PD_DECLARE_KERNEL(empty, GPU, ALL_LAYOUT);
#endif

namespace paddle {
namespace tests {

using Tensor = paddle::Tensor;
using DataType = phi::DataType;

template <typename T>
Tensor InitCPUTensorForTest() {
  std::vector<int64_t> tensor_shape{5, 5};
  DataType dtype = phi::CppTypeToDataType<T>::Type();
  Tensor t1 = paddle::experimental::empty(tensor_shape, dtype, phi::CPUPlace());
  auto* p_data_ptr = t1.data<T>();
  for (int64_t i = 0; i < t1.size(); i++) {
    p_data_ptr[i] = T(5);
  }
  return t1;
}

template <typename T>
void TestCopyTensor() {
  auto t1 = InitCPUTensorForTest<T>();
  auto t1_cpu_cp = t1.copy_to(phi::CPUPlace(), /*blocking=*/false);
  PADDLE_ENFORCE_EQ(t1_cpu_cp.place(),
                    phi::CPUPlace(),
                    common::errors::InvalidArgument("t1_cpu_cp should copy to "
                                                    "CPUPlace, but got %s",
                                                    t1_cpu_cp.place()));
  for (int64_t i = 0; i < t1.size(); i++) {
    PADDLE_ENFORCE_EQ(
        t1_cpu_cp.template data<T>()[i],
        T(5),
        common::errors::InvalidArgument(
            "t1_cpu_cp.template data<T>()[%d] should be equal to T(5) ", i));
  }
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
  VLOG(2) << "Do GPU copy test";
  auto t1_gpu_cp = t1_cpu_cp.copy_to(phi::GPUPlace(), /*blocking=*/false);
  PADDLE_ENFORCE_EQ(t1_gpu_cp.place(),
                    phi::GPUPlace(),
                    common::errors::InvalidArgument("t1_gpu_cp should copy to "
                                                    "GPUPlace, but got %s",
                                                    t1_gpu_cp.place()));
  auto t1_gpu_cp_cp = t1_gpu_cp.copy_to(phi::GPUPlace(), /*blocking=*/false);
  PADDLE_ENFORCE_EQ(
      t1_gpu_cp_cp.place(),
      phi::GPUPlace(),
      common::errors::InvalidArgument("t1_gpu_cp_cp should copy to "
                                      "GPUPlace, but got %s",
                                      t1_gpu_cp_cp.place()));
  auto t1_gpu_cp_cp_cpu =
      t1_gpu_cp_cp.copy_to(phi::CPUPlace(), /*blocking=*/false);
  PADDLE_ENFORCE_EQ(
      t1_gpu_cp_cp_cpu.place(),
      phi::CPUPlace(),
      common::errors::InvalidArgument("t1_gpu_cp_cp_cpu should copy to "
                                      "CPUPlace, but got %s",
                                      t1_gpu_cp_cp_cpu.place()));
  for (int64_t i = 0; i < t1.size(); i++) {
    PADDLE_ENFORCE_EQ(
        t1_gpu_cp_cp_cpu.template data<T>()[i],
        T(5),
        common::errors::InvalidArgument(
            "t1_gpu_cp_cp_cpu.template data<T>()[%d] should be equal to T(5) ",
            i));
  }
#endif
}

void TestAPIPlace() {
  std::vector<int64_t> tensor_shape = {5, 5};
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
  auto t1 = paddle::experimental::empty(
      tensor_shape, DataType::FLOAT32, phi::GPUPlace());
  PADDLE_ENFORCE_EQ(t1.place(),
                    phi::GPUPlace(),
                    common::errors::InvalidArgument(
                        "t1 should copy to GPUPlace, but got %s", t1.place()));
#endif
  auto t2 = paddle::experimental::empty(
      tensor_shape, DataType::FLOAT32, phi::CPUPlace());
  PADDLE_ENFORCE_EQ(t2.place(),
                    phi::CPUPlace(),
                    common::errors::InvalidArgument(
                        "t2 should copy to CPUPlace, but got %s", t2.place()));
}

void TestAPISizeAndShape() {
  std::vector<int64_t> tensor_shape = {5, 5};
  auto t1 = paddle::experimental::empty(tensor_shape);
  PADDLE_ENFORCE_EQ(
      t1.size(),
      25,
      common::errors::InvalidArgument("t1.size should be equal to 25, "
                                      "but got %d",
                                      t1.size()));
  PADDLE_ENFORCE_EQ(t1.shape(),
                    tensor_shape,
                    common::errors::InvalidArgument(
                        "t1.shape should be equal to tensor_shape, "));
}

void TestAPISlice() {
  std::vector<int64_t> tensor_shape_origin1 = {5, 5};
  std::vector<int64_t> tensor_shape_sub1 = {3, 5};
  std::vector<int64_t> tensor_shape_origin2 = {5, 5, 5};
  std::vector<int64_t> tensor_shape_sub2 = {1, 5, 5};
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
  auto t1 = paddle::experimental::empty(
      tensor_shape_origin1, DataType::FLOAT32, phi::GPUPlace());
  PADDLE_ENFORCE_EQ(
      t1.slice(0, 5).shape(),
      tensor_shape_origin1,
      common::errors::InvalidArgument("t1.slice(0, 5).shape should be equal to "
                                      "{5, 5}"));
  PADDLE_ENFORCE_EQ(
      t1.slice(0, 3).shape(),
      tensor_shape_sub1,
      common::errors::InvalidArgument("t1.slice(0, 3).shape should be equal to "
                                      "{3, 5}"));
  auto t2 = paddle::experimental::empty(
      tensor_shape_origin2, DataType::FLOAT32, phi::GPUPlace());
  PADDLE_ENFORCE_EQ(
      t2.slice(4, 5).shape(),
      tensor_shape_sub2,
      common::errors::InvalidArgument("t2.slice(4, 5).shape should be equal to "
                                      "{1, 5, 5}"));
#endif
  auto t3 = paddle::experimental::empty(
      tensor_shape_origin1, DataType::FLOAT32, phi::CPUPlace());
  PADDLE_ENFORCE_EQ(
      t3.slice(0, 5).shape(),
      tensor_shape_origin1,
      common::errors::InvalidArgument("t3.slice(0, 5).shape should be equal to "
                                      "{5, 5}"));
  PADDLE_ENFORCE_EQ(
      t3.slice(0, 3).shape(),
      tensor_shape_sub1,
      common::errors::InvalidArgument("t3.slice(0, 3).shape should be equal to "
                                      "{3, 5}"));
  auto t4 = paddle::experimental::empty(
      tensor_shape_origin2, DataType::FLOAT32, phi::CPUPlace());
  PADDLE_ENFORCE_EQ(
      t4.slice(4, 5).shape(),
      tensor_shape_sub2,
      common::errors::InvalidArgument("t4.slice(4, 5).shape should be equal to "
                                      "{1, 5, 5}"));

  // Test writing function for sliced tensor
  auto t = InitCPUTensorForTest<float>();
  auto t_sliced = t.slice(0, 1);
  auto* t_sliced_data_ptr = t_sliced.data<float>();
  for (int64_t i = 0; i < t_sliced.size(); i++) {
    t_sliced_data_ptr[i] += static_cast<float>(5);
  }
  auto* t_data_ptr = t.data<float>();
  for (int64_t i = 0; i < t_sliced.size(); i++) {
    PADDLE_ENFORCE_EQ(t_data_ptr[i],
                      static_cast<float>(10),
                      common::errors::InvalidArgument(
                          "Required t_data_ptr[%d] should be equal "
                          "to static_cast<float>(10) ",
                          i));
  }
}

template <typename T>
paddle::DataType TestDtype() {
  std::vector<int64_t> tensor_shape = {5, 5};
  DataType dtype = phi::CppTypeToDataType<T>::Type();
  auto t1 = paddle::experimental::empty(tensor_shape, dtype, phi::CPUPlace());
  return t1.type();
}

template <typename T>
void TestCast(paddle::DataType data_type) {
  std::vector<int64_t> tensor_shape = {5, 5};
  DataType dtype = phi::CppTypeToDataType<T>::Type();
  auto t1 = paddle::experimental::empty(tensor_shape, dtype, phi::CPUPlace());
  auto t2 = t1.cast(data_type);
  PADDLE_ENFORCE_EQ(
      t2.type(),
      data_type,
      common::errors::InvalidArgument("t2.type() should be equal to data_type, "
                                      "but got %s",
                                      t2.type()));
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
  auto tg1 = paddle::experimental::empty(tensor_shape, dtype, phi::GPUPlace());
  auto tg2 = tg1.cast(data_type);
  PADDLE_ENFORCE_EQ(tg2.type(),
                    data_type,
                    common::errors::InvalidArgument(
                        "tg2.type() should be equal to data_type, "
                        "but got %s",
                        tg2.type()));
#endif
}

void GroupTestCopy() {
  VLOG(2) << "Float cpu-cpu-gpu-gpu-cpu";
  TestCopyTensor<float>();
  VLOG(2) << "Double cpu-cpu-gpu-gpu-cpu";
  TestCopyTensor<double>();
  VLOG(2) << "int cpu-cpu-gpu-gpu-cpu";
  TestCopyTensor<int32_t>();
  VLOG(2) << "int64 cpu-cpu-gpu-gpu-cpu";
  TestCopyTensor<int64_t>();
  VLOG(2) << "int16 cpu-cpu-gpu-gpu-cpu";
  TestCopyTensor<int16_t>();
  VLOG(2) << "int8 cpu-cpu-gpu-gpu-cpu";
  TestCopyTensor<int8_t>();
  VLOG(2) << "uint8 cpu-cpu-gpu-gpu-cpu";
  TestCopyTensor<uint8_t>();
  VLOG(2) << "complex<float> cpu-cpu-gpu-gpu-cpu";
  TestCopyTensor<paddle::complex64>();
  VLOG(2) << "complex<double> cpu-cpu-gpu-gpu-cpu";
  TestCopyTensor<paddle::complex128>();
  VLOG(2) << "Fp16 cpu-cpu-gpu-gpu-cpu";
  TestCopyTensor<paddle::float16>();
}

void GroupTestCast() {
  VLOG(2) << "int16_t cast";
  TestCast<int16_t>(paddle::DataType::FLOAT32);
  VLOG(2) << "int32 cast";
  TestCast<int32_t>(paddle::DataType::FLOAT32);
  VLOG(2) << "int64 cast";
  TestCast<int64_t>(paddle::DataType::FLOAT32);
  VLOG(2) << "double cast";
  TestCast<double>(paddle::DataType::FLOAT32);
  VLOG(2) << "bool cast";
  TestCast<bool>(paddle::DataType::FLOAT32);
  VLOG(2) << "uint8 cast";
  TestCast<uint8_t>(paddle::DataType::FLOAT32);
  VLOG(2) << "float cast";
  TestCast<float>(paddle::DataType::FLOAT32);
  VLOG(2) << "complex<float> cast";
  TestCast<paddle::complex64>(paddle::DataType::FLOAT32);
  VLOG(2) << "complex<double> cast";
  TestCast<paddle::complex128>(paddle::DataType::FLOAT32);
  VLOG(2) << "float16 cast";
  TestCast<paddle::float16>(paddle::DataType::FLOAT16);
}

void GroupTestDtype() {
  PADDLE_ENFORCE_EQ(
      TestDtype<bool>(),
      paddle::DataType::BOOL,
      common::errors::InvalidArgument("TestDtype<bool>() should be equal to "
                                      "paddle::DataType::BOOL, but got %s",
                                      TestDtype<bool>()));
  PADDLE_ENFORCE_EQ(
      TestDtype<int8_t>(),
      paddle::DataType::INT8,
      common::errors::InvalidArgument("TestDtype<int8_t>() should be equal to "
                                      "paddle::DataType::INT8, but got %s",
                                      TestDtype<int8_t>()));
  PADDLE_ENFORCE_EQ(
      TestDtype<uint8_t>(),
      paddle::DataType::UINT8,
      common::errors::InvalidArgument("TestDtype<uint8_t>() should be equal to "
                                      "paddle::DataType::UINT8, but got %s",
                                      TestDtype<uint8_t>()));
  PADDLE_ENFORCE_EQ(
      TestDtype<int16_t>(),
      paddle::DataType::INT16,
      common::errors::InvalidArgument("TestDtype<int16_t>() should be equal to "
                                      "paddle::DataType::INT16, but got %s",
                                      TestDtype<int16_t>()));
  PADDLE_ENFORCE_EQ(
      TestDtype<int32_t>(),
      paddle::DataType::INT32,
      common::errors::InvalidArgument("TestDtype<int32_t>() should be equal to "
                                      "paddle::DataType::INT32, but got %s",
                                      TestDtype<int32_t>()));
  PADDLE_ENFORCE_EQ(
      TestDtype<int64_t>(),
      paddle::DataType::INT64,
      common::errors::InvalidArgument("TestDtype<int64_t>() should be equal to "
                                      "paddle::DataType::INT64, but got %s",
                                      TestDtype<int64_t>()));
  PADDLE_ENFORCE_EQ(TestDtype<paddle::float16>(),
                    paddle::DataType::FLOAT16,
                    common::errors::InvalidArgument(
                        "TestDtype<paddle::float16>() should be equal to "
                        "paddle::DataType::FLOAT16, but got %s",
                        TestDtype<paddle::float16>()));
  PADDLE_ENFORCE_EQ(
      TestDtype<float>(),
      paddle::DataType::FLOAT32,
      common::errors::InvalidArgument("TestDtype<float>() should be equal to "
                                      "paddle::DataType::FLOAT32, but got %s",
                                      TestDtype<float>()));
  PADDLE_ENFORCE_EQ(
      TestDtype<double>(),
      paddle::DataType::FLOAT64,
      common::errors::InvalidArgument("TestDtype<double>() should be equal to "
                                      "paddle::DataType::FLOAT64, but got %s",
                                      TestDtype<double>()));
  PADDLE_ENFORCE_EQ(TestDtype<paddle::complex64>(),
                    paddle::DataType::COMPLEX64,
                    common::errors::InvalidArgument(
                        "TestDtype<paddle::complex64>() should be equal to "
                        "paddle::DataType::COMPLEX64, but got %s",
                        TestDtype<paddle::complex64>()));
  PADDLE_ENFORCE_EQ(TestDtype<paddle::complex128>(),
                    paddle::DataType::COMPLEX128,
                    common::errors::InvalidArgument(
                        "TestDtype<paddle::complex128>() should be equal to "
                        "paddle::DataType::COMPLEX128, but got %s",
                        TestDtype<paddle::complex128>()));
}

void TestInitialized() {
  auto test_tensor = paddle::experimental::empty({1, 1});
  PADDLE_ENFORCE_EQ(test_tensor.initialized(),
                    true,
                    common::errors::InvalidArgument(
                        "test_tensor should be initialized, but got %s",
                        test_tensor.initialized()));
  float* tensor_data = test_tensor.data<float>();
  for (int i = 0; i < test_tensor.size(); i++) {
    tensor_data[i] = 0.5;
  }
  for (int i = 0; i < test_tensor.size(); i++) {
    PADDLE_ENFORCE_EQ(tensor_data[i],
                      0.5,
                      common::errors::InvalidArgument(
                          "tensor_data[%d] should be equal to 0.5, "
                          "but got %f",
                          i,
                          tensor_data[i]));
  }
}

void TestDataInterface() {
  // Test DenseTensor
  auto test_tensor = paddle::experimental::empty({1, 1});
  PADDLE_ENFORCE_EQ(test_tensor.initialized(),
                    true,
                    common::errors::InvalidArgument(
                        "test_tensor should be initialized, but got %s",
                        test_tensor.initialized()));
  void* tensor_ptr = test_tensor.data();
  PADDLE_ENFORCE_NE(
      tensor_ptr,
      nullptr,
      common::errors::InvalidArgument(
          "test_tensor should not be NULL, but got %p", tensor_ptr));
  const void* const_tensor_ptr = test_tensor.data();
  PADDLE_ENFORCE_NE(
      const_tensor_ptr,
      nullptr,
      common::errors::InvalidArgument("const_tensor should not be NULL, "
                                      "but got %p",
                                      const_tensor_ptr));
  // Test SelectedRows
  std::vector<int64_t> rows = {0};
  std::shared_ptr<phi::SelectedRows> selected_rows =
      std::make_shared<phi::SelectedRows>(rows, 1);
  selected_rows->mutable_value()->Resize(common::make_ddim({1, 1}));
  selected_rows->mutable_value()->mutable_data<float>(phi::CPUPlace())[0] =
      static_cast<float>(10.0f);
  paddle::Tensor sr_tensor = paddle::Tensor(selected_rows);
  PADDLE_ENFORCE_EQ(sr_tensor.initialized(),
                    true,
                    common::errors::InvalidArgument(
                        "sr_tensor should be initialized, but got %s",
                        sr_tensor.initialized()));
  tensor_ptr = sr_tensor.data();
  PADDLE_ENFORCE_NE(tensor_ptr,
                    nullptr,
                    common::errors::InvalidArgument(
                        "tensor should not be NULL, but got %p", tensor_ptr));
  const_tensor_ptr = sr_tensor.data();
  PADDLE_ENFORCE_NE(
      const_tensor_ptr,
      nullptr,
      common::errors::InvalidArgument("const_tensor should not be NULL, "
                                      "but got %p",
                                      const_tensor_ptr));
}

TEST(PhiTensor, All) {
  VLOG(2) << "TestCopy";
  GroupTestCopy();
  VLOG(2) << "TestDtype";
  GroupTestDtype();
  VLOG(2) << "TestShape";
  TestAPISizeAndShape();
  VLOG(2) << "TestPlace";
  TestAPIPlace();
  VLOG(2) << "TestSlice";
  TestAPISlice();
  VLOG(2) << "TestCast";
  GroupTestCast();
  VLOG(2) << "TestInitialized";
  TestInitialized();
  VLOG(2) << "TestDataInterface";
  TestDataInterface();
}

}  // namespace tests
}  // namespace paddle