/* Copyright 2023 The TensorFlow 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.
==============================================================================*/

// Functions to perform integer evaluation for standard LSTM (e.g., defined in
// the keras lstm layer, no peephole etc.). Currently used by the 16 bits
// activation case only

#ifndef TENSORFLOW_LITE_MICRO_KERNELS_LSTM_EVAL_GENERAL_H_
#define TENSORFLOW_LITE_MICRO_KERNELS_LSTM_EVAL_GENERAL_H_
#include <algorithm>
#include <cstdint>

#include "tensorflow/lite/c/builtin_op_data.h"
#include "tensorflow/lite/c/common.h"
#include "tensorflow/lite/micro/kernels/kernel_util.h"
#include "tensorflow/lite/micro/kernels/lstm_shared.h"
#include "tensorflow/lite/micro/micro_log.h"

namespace tflite {

// Interface to access all the TempTfLiteTensors of the LSTM kernel during the
// preparation phase. Can only be constructed through the constructor to avoid
// memory leakage. All TempTfLiteTensors will be deallocated through the
// destructor.
class LstmTensors {
 public:
  LstmTensors(const LstmTensors& other) = delete;
  LstmTensors& operator=(const LstmTensors& other) = delete;

  LstmTensors(TfLiteContext* context, TfLiteNode* node);
  ~LstmTensors();

  // Verify the LSTM internal tensor properties (e.g., type checks)
  // Input/output/states/fc weights tensors are required for kernel evaluation.
  // The state tensors should be variables. Variants of the standard LSTM
  // are not supported here, therefore their corresponding tensors should be
  // invalid
  TfLiteStatus ValidateTensorStatus(TfLiteContext* context) const;

  // Internal tensors. see lstm_shared.h for tensor names
  const TfLiteTensor* GetInternalTensor(const int tensor_index) const {
    return internal_tensors_[tensor_index];
  }

  const TfLiteTensor* HiddenStateTensor() const {
    return internal_tensors_[kLstmOutputStateTensor];
  }
  const TfLiteTensor* CellStateTensor() const {
    return internal_tensors_[kLstmCellStateTensor];
  }
  const TfLiteTensor* OutputTensor() const { return output_tensor_; }

 private:
  // see lstm_shared.h for tensor names
  MicroContext* micro_context_;
  TfLiteTensor* internal_tensors_[24];
  TfLiteTensor* output_tensor_;
};

// Deduce the size information (Batch (B), Time Steps (T), Input dimension (I),
// State dimension (S)) that defines the LSTM using the input and hidden state
// tensor
LstmSizeInfo CreateLstmSizeInfo(
    const bool time_major, const TfLiteIntArray* input_tensor_shape,
    const TfLiteIntArray* hidden_state_tensor_shape);

TfLiteStatus ValidateWeightTensorSize(TfLiteContext* context,
                                      const TfLiteTensor* tensor, int dim1_size,
                                      int dim2_size);

TfLiteStatus ValidateBiasTensorSize(TfLiteContext* context,
                                    const TfLiteTensor* tensor, int size);

// Go through every tensors and make sure their shape match the kernel
// configuration
TfLiteStatus ValidateTensorSize(TfLiteContext* context,
                                const LstmTensors& tensors,
                                const LstmSizeInfo& size_info);

// Wrapper function to create gate parameters for the four internal LSTM gates
TfLiteStatus CreateGateParams(
    TfLiteContext* context,
    /*Input tensors*/
    const TfLiteTensor* input, const TfLiteTensor* input_weight,
    const TfLiteTensor* input_bias,
    /*Hidden state tensors*/
    const TfLiteTensor* hidden_state, const TfLiteTensor* hidden_state_weight,
    const TfLiteTensor* hidden_state_bias,
    /*Scale of the fc output (input to non-linear activation)*/
    const float nonlinear_activation_input_scale, const TfLiteType cell_type,
    const tflite::GateParameters& gate_params);

// Create parameters for element wise multiplication that happens in a) cell
// state update ; b) hidden state update
// Note that all the output of gates are symmetrically quantized so only scales
// are required for input. However, during the hidden state update phase, the
// output is the updated hidden state, which is asymmetrically quantized. Thus
// output may require zero point
tflite::ArithmeticParams CreateInterGateMulParams(const float input1_scale,
                                                  const float input2_scale,
                                                  const float output_scale,
                                                  const TfLiteType output_type,
                                                  const int output_zp = 0);

// Create the additional information about the cell state, which include:
// cell_state_scale_power: used in integer nonlinear function (e.g., tanh)
// quantized_cell_clip: quantized cell clip range
CellStateInfo CreateLstmCellStateInfo(const float cell_state_scale,
                                      const float cell_clip);

CellStateInfo CreateLstmCellStateInfoFloat(const float cell_clip);
tflite::FullyConnectedParams CreateFCParamsFloat();

tflite::GateParameters CreateGateParamsFloat();

tflite::ArithmeticParams CreateInterGateMulParamsFloat();

TfLiteStatus PrepareGateParametersFloat(TfLiteContext* context,
                                        const LstmTensors& lstm_tensors,
                                        OpDataLSTM* op_data_lstm);

TfLiteStatus PrepareGateParametersInteger(TfLiteContext* context,
                                          const LstmTensors& lstm_tensors,
                                          OpDataLSTM* op_data_lstm);

LSTMKernelContents CreateLSTMKernelContent(TfLiteContext* context,
                                           TfLiteNode* node);

template <typename CellType>
LSTMBuffers<CellType> CreateLSTMBuffers(TfLiteContext* context,
                                        const int* buffer_indices) {
  LSTMBuffers<CellType> buffers;
  buffers.buffer0 = reinterpret_cast<CellType*>(
      context->GetScratchBuffer(context, buffer_indices[0]));
  buffers.buffer1 = reinterpret_cast<CellType*>(
      context->GetScratchBuffer(context, buffer_indices[1]));
  buffers.buffer2 = reinterpret_cast<CellType*>(
      context->GetScratchBuffer(context, buffer_indices[2]));
  buffers.buffer3 = reinterpret_cast<CellType*>(
      context->GetScratchBuffer(context, buffer_indices[3]));
  return buffers;
}

// Since LSTM includes multiple intermediate stages, introducing the internal
// namespace to expose them for testing
namespace lstm_internal {

void Sigmoid(const RuntimeShape& data_shape, int16_t* data);

void Sigmoid(const RuntimeShape& data_shape, float* data);

void Tanh(int32_t cell_state_scale_power, const RuntimeShape& input_data_shape,
          int16_t* input_data, const RuntimeShape& output_data_shape,
          int16_t* output_data);

void Tanh(int32_t cell_state_scale_power, const RuntimeShape& input_data_shape,
          float* input_data, const RuntimeShape& output_data_shape,
          float* output_data);

void Mul(const RuntimeShape& shape, const ArithmeticParams& params,
         const int16_t* input1_data, const int16_t* input2_data,
         int8_t* output_data);

void Mul(const RuntimeShape& shape, const ArithmeticParams& params,
         const int16_t* input1_data, const int16_t* input2_data,
         int16_t* output_data);

void Mul(const RuntimeShape& shape, const ArithmeticParams& params,
         const float* input1_data, const float* input2_data,
         float* output_data);

void FullyConnected(const FullyConnectedParams& params,
                    const RuntimeShape& input_shape, const int8_t* input_data,
                    const RuntimeShape& filter_shape, const int8_t* filter_data,
                    const RuntimeShape& bias_shape, const int32_t* bias_data,
                    const RuntimeShape& output_shape, int16_t* output_data);

void FullyConnected(const FullyConnectedParams& params,
                    const RuntimeShape& input_shape, const int16_t* input_data,
                    const RuntimeShape& filter_shape, const int8_t* filter_data,
                    const RuntimeShape& bias_shape, const int64_t* bias_data,
                    const RuntimeShape& output_shape, int16_t* output_data);

void FullyConnected(const FullyConnectedParams& params,
                    const RuntimeShape& input_shape, const float* input_data,
                    const RuntimeShape& filter_shape, const float* filter_data,
                    const RuntimeShape& bias_shape, const float* bias_data,
                    const RuntimeShape& output_shape, float* output_data);

void AddElementWise(const int16_t* input_1, const int16_t* input_2, int n_batch,
                    int n_input, int16_t* output);

void AddElementWise(const float* input_1, const float* input_2, int n_batch,
                    int n_input, float* output);

void Clipping(const int v_size, const CellStateInfo& cell_state_info,
              int16_t* vector);

void Clipping(const int v_size, const CellStateInfo& cell_state_info,
              float* vector);

// Manages the slice position (offset), slice length (sliced tensor shape),
// and update rules for input/output/hidden state/cell state tensors at each
// time step.
class LstmStepManager {
 public:
  LstmStepManager() = delete;
  // Does not take any ownership, and all pointers must refer to valid objects
  // that outlive the one constructed.
  explicit LstmStepManager(const LstmSizeInfo* size_info)
      : size_info_(*size_info) {}

  void UpdateTime();
  void UpdateBatch();

  void ResetTime() { current_time_ = 0; }
  RuntimeShape InputShape() const;
  RuntimeShape StateShape() const;

  int InputOffset() const { return input_offset_; }
  int OutputOffset() const { return output_offset_; }
  int HiddenStateOffset() const { return hidden_state_offset_; }
  int CellStateOffset() const { return cell_state_offset_; }

 private:
  int current_time_ = 0;
  int current_batch_ = 0;
  int input_offset_ = 0;
  int output_offset_ = 0;
  int hidden_state_offset_ = 0;
  int cell_state_offset_ = 0;
  // Sizeinfo is from LstmOpData, which reside in the memory arena
  // (guarantee to outlast LSTMStepManager, which reside in stack)
  const LstmSizeInfo& size_info_;
};

// Calculates a single LSTM gate.
// Implements the following formula:
//   gate = activate(FC(input) + FC(recurrent))
// Activation is sigmoid except for the "cell" gate (configurable, usually tanh)
template <typename ActivationType, typename WeightType, typename CellType,
          typename BiasType>
void CalculateLstmGate(
    const LstmStepManager& step_info, const GateParameters& gate_params,
    // Input FC
    const TfLiteEvalTensor* input, const TfLiteEvalTensor* input_weight,
    const TfLiteEvalTensor* input_bias,
    // Recurrent FC
    const TfLiteEvalTensor* recurrent, const TfLiteEvalTensor* recurrent_weight,
    const TfLiteEvalTensor* recurrent_bias,
    // Output
    CellType* gate_output,
    // Scratch arrays
    CellType* fc_output_buffer, const TfLiteFusedActivation activation) {
  const auto gate_output_shape = step_info.StateShape();
  // Check offset validity to avoid memory overflow
  TFLITE_DCHECK_LE(step_info.InputOffset() + step_info.InputShape().FlatSize(),
                   tflite::micro::GetTensorShape(input).FlatSize());
  TFLITE_DCHECK_LE(
      step_info.HiddenStateOffset() + step_info.StateShape().FlatSize(),
      tflite::micro::GetTensorShape(recurrent).FlatSize());

  // Input FC
  FullyConnected(gate_params.input_fc_params, step_info.InputShape(),
                 tflite::micro::GetTensorData<ActivationType>(input) +
                     step_info.InputOffset(),
                 micro::GetTensorShape(input_weight),
                 tflite::micro::GetTensorData<WeightType>(input_weight),
                 tflite::micro::GetTensorShape(input_bias),
                 tflite::micro::GetOptionalTensorData<BiasType>(input_bias),
                 gate_output_shape, gate_output);

  // Recurrent FC
  FullyConnected(gate_params.recurrent_fc_params, step_info.StateShape(),
                 tflite::micro::GetTensorData<ActivationType>(recurrent) +
                     step_info.HiddenStateOffset(),
                 tflite::micro::GetTensorShape(recurrent_weight),
                 tflite::micro::GetTensorData<WeightType>(recurrent_weight),
                 tflite::micro::GetTensorShape(recurrent_bias),
                 tflite::micro::GetOptionalTensorData<BiasType>(recurrent_bias),
                 gate_output_shape, fc_output_buffer);

  AddElementWise(gate_output, fc_output_buffer,
                 /*n_batch=*/gate_output_shape.DimsData()[0],
                 /*n_state=*/gate_output_shape.DimsData()[1], gate_output);
  // Apply activation
  switch (activation) {
    case kTfLiteActSigmoid:
      Sigmoid(gate_output_shape, gate_output);
      break;
    case kTfLiteActTanh: {
      // Set the scale power to -12 to avoid shift
      Tanh(/*cell_state_scale_power=*/-12, gate_output_shape, gate_output,
           gate_output_shape, gate_output);
    } break;
    default:
      // Only Sigmoid or Tanh is used.
      TFLITE_ASSERT_FALSE;
  }
}

// Update the cell state using the output from the forget gate, input gate, and
// cell gate Formula: updated_cell_state = forget_gate_output*cell_state +
// input_gate_output * cell_gate_output, where * denotes element wise
// multiplication
template <typename CellType>
void UpdateLstmCell(const LstmStepManager& step_info,
                    TfLiteEvalTensor* cell_state,
                    // Gate outputs
                    CellType* forget_gate_output,
                    const CellType* input_gate_output,
                    const CellType* cell_gate_output,
                    // Mul parameters
                    const ArithmeticParams& forget_cell_mul_params,
                    const ArithmeticParams& input_mul_params,
                    const CellStateInfo& cell_state_info, CellType* buffer) {
  // Check offset validity to avoid memory overflow
  TFLITE_DCHECK_LE(
      step_info.CellStateOffset() + step_info.StateShape().FlatSize(),
      tflite::micro::GetTensorShape(cell_state).FlatSize());

  auto cell_state_shape = step_info.StateShape();
  // Forget Gate x Cell State
  Mul(cell_state_shape, forget_cell_mul_params, forget_gate_output,
      tflite::micro::GetTensorData<CellType>(cell_state) +
          step_info.CellStateOffset(),
      tflite::micro::GetTensorData<CellType>(cell_state) +
          step_info.CellStateOffset());
  // Input Gate x Cell Gate
  Mul(cell_state_shape, input_mul_params, input_gate_output, cell_gate_output,
      buffer);

  // Update the cell state
  AddElementWise(tflite::micro::GetTensorData<CellType>(cell_state) +
                     step_info.CellStateOffset(),
                 buffer,
                 /*n_batch=*/cell_state_shape.DimsData()[0],
                 /*n_state=*/cell_state_shape.DimsData()[1],
                 tflite::micro::GetTensorData<CellType>(cell_state) +
                     step_info.CellStateOffset());

  if (cell_state_info.cell_clip > 0) {
    Clipping(cell_state_shape.FlatSize(), cell_state_info,
             tflite::micro::GetTensorData<CellType>(cell_state) +
                 step_info.CellStateOffset());
  }
}

// Update the hidden state of the LSTM kernel using the following formula:
// updated_hidden_state = Tanh(updated_cell_state) * output_gate_output, * means
// element wise multiplication
template <typename CellType, typename ActivationType>
void UpdateLstmHidden(const LstmStepManager& step_info,
                      TfLiteEvalTensor* cell_state,
                      TfLiteEvalTensor* hidden_state,
                      const CellType* output_gate_output,
                      const ArithmeticParams& mul_params,
                      int32_t cell_state_scale_power, CellType* buffer) {
  // Check offset validity to avoid memory overflow
  TFLITE_DCHECK_LE(
      step_info.CellStateOffset() + step_info.StateShape().FlatSize(),
      tflite::micro::GetTensorShape(cell_state).FlatSize());
  TFLITE_DCHECK_LE(
      step_info.HiddenStateOffset() + step_info.StateShape().FlatSize(),
      tflite::micro::GetTensorShape(hidden_state).FlatSize());

  auto cell_state_shape = step_info.StateShape();
  CellType* cell_state_data =
      tflite::micro::GetTensorData<CellType>(cell_state) +
      step_info.CellStateOffset();
  // Tanh(cell_state)
  Tanh(cell_state_scale_power, cell_state_shape, cell_state_data,
       cell_state_shape, buffer);
  // Update the hidden state
  Mul(cell_state_shape, mul_params, buffer, output_gate_output,
      tflite::micro::GetTensorData<ActivationType>(hidden_state) +
          step_info.HiddenStateOffset());
}

template <typename ActivationType, typename WeightType, typename CellType,
          typename BiasType>
void LstmStep(const LstmStepManager& step_info, const OpDataLSTM& op_data,
              LSTMKernelContents& kernel_content,
              const LSTMBuffers<CellType>& buffers) {
  /*Step1: Calculate gate outputs to prepare cell state update*/
  CellType* gate_internal_buffer = buffers.buffer3;
  CellType* forget_gate_output = buffers.buffer0;
  CalculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
      step_info, op_data.forget_gate_parameters,
      // Input FC
      kernel_content.GetInternalTensor(tflite::kLstmInputTensor),
      kernel_content.GetInternalTensor(tflite::kLstmInputToForgetWeightsTensor),
      kernel_content.GetInternalTensor(tflite::kLstmForgetGateBiasTensor),
      // Recurrent FC
      kernel_content.HiddenStateTensor(),
      kernel_content.GetInternalTensor(
          tflite::kLstmRecurrentToForgetWeightsTensor),
      /*recurrent_bias*/ nullptr,
      // Output
      forget_gate_output,
      // Scratch arrays
      gate_internal_buffer, kTfLiteActSigmoid);

  // Input Gate calculation;
  CellType* input_gate_output = buffers.buffer1;
  CalculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
      step_info, op_data.input_gate_parameters,
      // Input FC
      kernel_content.GetInternalTensor(tflite::kLstmInputTensor),
      kernel_content.GetInternalTensor(tflite::kLstmInputToInputWeightsTensor),
      kernel_content.GetInternalTensor(tflite::kLstmInputGateBiasTensor),
      // Recurrent FC
      kernel_content.HiddenStateTensor(),
      kernel_content.GetInternalTensor(
          tflite::kLstmRecurrentToInputWeightsTensor),
      /*recurrent_bias*/ nullptr,
      // Output
      input_gate_output,
      // Scratch arrays
      gate_internal_buffer, kTfLiteActSigmoid);

  // Cell Gate calculation
  CellType* cell_gate_output = buffers.buffer2;
  CalculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
      step_info, op_data.cell_gate_parameters,
      // Input FC
      kernel_content.GetInternalTensor(tflite::kLstmInputTensor),
      kernel_content.GetInternalTensor(tflite::kLstmInputToCellWeightsTensor),
      kernel_content.GetInternalTensor(tflite::kLstmCellGateBiasTensor),
      // Recurrent FC
      kernel_content.HiddenStateTensor(),
      kernel_content.GetInternalTensor(
          tflite::kLstmRecurrentToCellWeightsTensor),
      /*recurrent_bias*/ nullptr,
      // Output
      cell_gate_output,
      // Scratch arrays
      gate_internal_buffer, op_data.cell_gate_nonlinear_type);

  /*Step2: update the cell state */
  const InterGateParameters& inter_gate_params = op_data.inter_gate_parameters;
  CellType* updated_input_buffer = buffers.buffer1;  // reuse buffer

  UpdateLstmCell<CellType>(step_info, kernel_content.CellStateTensor(),
                           forget_gate_output, input_gate_output,
                           cell_gate_output,
                           inter_gate_params.forget_cell_mul_params,
                           inter_gate_params.input_mul_params,
                           op_data.cell_state_info, updated_input_buffer);

  /*Step3: update the hidden state */
  CellType* output_gate_output = buffers.buffer1;  // reuse buffer
  CalculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
      step_info, op_data.output_gate_parameters,
      // Input FC
      kernel_content.GetInternalTensor(tflite::kLstmInputTensor),
      kernel_content.GetInternalTensor(tflite::kLstmInputToOutputWeightsTensor),
      kernel_content.GetInternalTensor(tflite::kLstmOutputGateBiasTensor),
      // Recurrent FC
      kernel_content.HiddenStateTensor(),
      kernel_content.GetInternalTensor(
          tflite::kLstmRecurrentToOutputWeightsTensor),
      /*recurrent_bias*/ nullptr,
      // Output
      output_gate_output,
      // Scratch arrays
      gate_internal_buffer, kTfLiteActSigmoid);

  CellType* tanh_activated_cell_buffer = buffers.buffer0;  // reuse buffer
  tflite::lstm_internal::UpdateLstmHidden<CellType, ActivationType>(
      step_info, kernel_content.CellStateTensor(),
      kernel_content.HiddenStateTensor(), output_gate_output,
      inter_gate_params.output_mul_params,
      op_data.cell_state_info.cell_state_scale_power,
      tanh_activated_cell_buffer);

  /*Step4: copy the update the hidden state to output*/
  // Check offset validity to avoid memory overflow
  TFLITE_DCHECK_LE(
      step_info.OutputOffset() + step_info.StateShape().FlatSize(),
      tflite::micro::GetTensorShape(kernel_content.output_tensor).FlatSize());
  // record the output (from the updated hidden state)
  ActivationType* output_ptr = tflite::micro::GetTensorData<ActivationType>(
      kernel_content.output_tensor);
  const auto* hidden_state = kernel_content.HiddenStateTensor();
  std::memcpy(output_ptr + step_info.OutputOffset(),
              tflite::micro::GetTensorData<ActivationType>(hidden_state) +
                  step_info.HiddenStateOffset(),
              step_info.StateShape().FlatSize() * sizeof(ActivationType));
}

}  // namespace lstm_internal

// Evaluate the LSTM kernel with (potential) multi-steps and multi-batch input
// Since
template <typename ActivationType, typename WeightType, typename CellType,
          typename BiasType>
TfLiteStatus EvalLstm(const OpDataLSTM& op_data,
                      LSTMKernelContents& kernel_content,
                      const LSTMBuffers<CellType>& buffers) {
  lstm_internal::LstmStepManager step_info(&op_data.size_info);
  const auto& size_info = op_data.size_info;
  // time is the first dimension, enable batch computation
  if (size_info.time_major) {
    for (int t = 0; t < size_info.time_steps; t++) {
      lstm_internal::LstmStep<ActivationType, WeightType, CellType, BiasType>(
          step_info, op_data, kernel_content, buffers);
      // prepare for the next time step
      step_info.UpdateTime();
    }
  } else {
    // batch first, unable to size the input data. single batch inference
    for (int b = 0; b < size_info.batch_size; b++) {
      for (int t = 0; t < size_info.time_steps; t++) {
        lstm_internal::LstmStep<ActivationType, WeightType, CellType, BiasType>(
            step_info, op_data, kernel_content, buffers);
        // prepare for the next time step
        step_info.UpdateTime();
      }
      // prepare for the next batch
      step_info.UpdateBatch();
      step_info.ResetTime();
    }
  }
  return kTfLiteOk;
}
}  // namespace tflite

#endif  // TENSORFLOW_LITE_MICRO_KERNELS_LSTM_EVAL_16ACT_H_
