#include "tensorflow/compiler/mlir/lite/schema/schema_generated.h"
#include "tensorflow/core/framework/tensor.pb.h"
#include "tensorflow/core/framework/tensor_shape.pb.h"

namespace mlir {
namespace TFL {

bool IsQuantized(const tflite::TensorT& tensor);

absl::StatusOr<mlir::quant::QuantizedType> GetQuantizedType(
    const tflite::TensorT& tensor, mlir::Builder builder,
    bool is_constant = false, mlir::Type storage_type = {});

  }
}

}  // namespace

bool IsQuantized(const TensorT& tensor) {
  return (tensor.quantization != nullptr) &&
         !tensor.quantization->zero_point.empty();
}

// Returns the correct type for a quantized tensor.
// We have a special case for constants since they have a higher minimum value.
StatusOr<QuantizedType> GetQuantizedType(const TensorT& tensor, Builder builder,

// of intermediate tensors since importer doesn't guarantee to preserve tensor
// names except output tensors.
Location OpLoc(const OperatorT& op,
               const std::vector<std::unique_ptr<tflite::TensorT>>& tensors,
               Builder builder, Location base) {
  if (op.outputs.empty()) return base;

  llvm::SmallVector<Location, 4> locations;
  locations.reserve(op.outputs.size());

  // There should be 3 tensors: input, output, and BroadcastTo/shape.
  EXPECT_THAT(subgraph->tensors, SizeIs(3));

  // Input Tensor
  EXPECT_THAT(subgraph->tensors[0]->type, Eq(tensor_type_));
  EXPECT_THAT(subgraph->tensors[0]->name, Eq("input_1"));
  EXPECT_THAT(subgraph->tensors[0]->quantization->scale, SizeIs(1));
  EXPECT_THAT(subgraph->tensors[0]->quantization->zero_point, SizeIs(1));

  std::vector<std::unique_ptr<tflite::VariantSubTypeT>> variant_tensors{};
  TensorT() = default;
  TensorT(const TensorT &o);
  TensorT(TensorT&&) FLATBUFFERS_NOEXCEPT = default;
  TensorT &operator=(TensorT o) FLATBUFFERS_NOEXCEPT;
};

struct Tensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TensorT NativeTableType;
  typedef TensorBuilder Builder;

package com.acme;

import dagger.Module;
import dagger.Provides;

@Module
public class Sensors {
    @Provides static HeatSensor provideHeater() {
        return new DefaultHeatSensor();
    }

package com.acme;

import dagger.Module;
import dagger.Provides;

@Module
public class Sensors {
    @Provides static HeatSensor provideHeater() {
        return new DefaultHeatSensor();
    }

  TF_ASSERT_OK_AND_ASSIGN(Tensor tensor1,
                          runtime.CreateHostTensor<float>({}, TF_FLOAT, {2.0f}))
  TF_ASSERT_OK_AND_ASSIGN(Tensor tensor2,
                          runtime.CreateHostTensor<float>({}, TF_FLOAT, {3.0f}))

  TF_ASSERT_OK_AND_ASSIGN(Tensor result_tensor,
                          fn.Call<Tensor>(tensor1, tensor2));
  float out_val[1];

  CHECK(SerializeToTString(s, output_tstring));
  TF_DeleteTensor(summary_tensor);
}

bool IsSameSize(TF_Tensor* tensor1, TF_Tensor* tensor2) {
  if (TF_NumDims(tensor1) != TF_NumDims(tensor2)) {
    return false;
  }
  for (int d = 0; d < TF_NumDims(tensor1); d++) {
    if (TF_Dim(tensor1, d) != TF_Dim(tensor2, d)) {
      return false;
    }
  }
  return true;
}

std::string SingleTag(TF_Tensor* tags) {

  %0 = "tf.TensorListFromTensor"(%arg0, %arg1) : (tensor<*xf32>, tensor<1xi32>) -> tensor<!tf_type.variant<tensor<*xf32>>>
  %1 = "tf.TensorListGetItem"(%0, %arg2, %arg1) : (tensor<!tf_type.variant<tensor<*xf32>>>, tensor<i32>, tensor<1xi32>) -> tensor<*xf32>
  %2 = "tf.TensorListStack"(%0, %arg1) : (tensor<!tf_type.variant<tensor<*xf32>>>, tensor<1xi32>) -> tensor<*xf32>
  func.return %1, %2 : tensor<*xf32>, tensor<*xf32>