/*
 * Copyright (c) 2018 Samsung Electronics Co., Ltd. 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.
 */

#ifndef _NNC_SOFT_BACKEND_CPP_GENERATOR_H_
#define _NNC_SOFT_BACKEND_CPP_GENERATOR_H_

#include "BaseGenerator.h"

namespace nnc
{

namespace sir
{
struct TensorDescriptor;
struct Action;
struct CallFunction;
struct TransposeTensor;
struct CreateTmp;
struct DestroyTmp;
} // namespace sir

/**
 * @brief CPPCodeGenerator implements interfaces that provides BaseCodeGenerator for C++ language
 * This includes header file generation, code file generation and variable renaming according to C++
 * naming requirements
 */
class CPPCodeGenerator final : public BaseCodeGenerator
{
protected:
  void formatTensorNames(const ModelAnalyzer &ma) override;
  void materializeHeader(std::ostream &out, const ModelAnalyzer &ma) override;

  /**
   * @brief Form list of function call arguments
   * @param ma Intermediate model representation
   * @param argIds List of argument variable ids
   * @param args Result list of arguments transformed in form of strings
   */
  void gatherOperationArguments(const ModelAnalyzer &ma, const std::vector<size_t> &arg_ids,
                                std::vector<std::string> &args);
  /**
   * @brief Prints setter of artifact
   * @param out Output stream
   * @param className Name of artifact
   * @param setterName Name of setter function
   * @param varId id of variable that setter fills
   */
  void printSetter(std::ostream &out, const std::string &class_name, const std::string &setter_name,
                   const sir::TensorDescriptor &td);
  /**
   * @brief Prints getters of artifact
   * @param out Output stream
   * @param className Name of artifact
   * @param setterName Name of setter function
   * @param varId id of variable that getter returns
   */
  void printGetter(std::ostream &out, const std::string &class_name, const std::string &getter_name,
                   const sir::TensorDescriptor &td);
  /**
   * @brief Generate code for function call action
   * @param out Output stream to print
   * @param ma Intermediate model representation
   * @param call Action to generate code from
   */
  void materializeCall(std::ostream &out, const ModelAnalyzer &ma,
                       const nnc::sir::CallFunction *call);
  /**
   * @brief Generate code for transpose action
   * @param out Output stream to print
   * @param ma Intermediate model representation
   * @param action Action to generate code from
   */
  void materializeTranspose(std::ostream &out, const ModelAnalyzer &ma,
                            const nnc::sir::TransposeTensor *transpose);
  /**
   * @brief Generate code for constructor action
   * @param out Output stream to print
   * @param ma Intermediate model representation
   * @param action Action to generate code from
   */
  void materializeConstructor(std::ostream &out, const ModelAnalyzer &ma,
                              const nnc::sir::CreateTmp *constructor);
  /**
   * @brief Generate code for destructor action
   * @param out Output stream to print
   * @param ma Intermediate model representation
   * @param action Action to generate code from
   */
  void materializeDestructor(std::ostream &out, const ModelAnalyzer &ma,
                             const nnc::sir::DestroyTmp *destructor);
  /**
   * @brief Prints inference sequence placed in doInference method of artifact
   * @param out Output stream
   * @param ma Intermediate model representation
   */
  void materializeInferenceSequence(std::ostream &out, const ModelAnalyzer &ma);
  void materializeCode(std::ostream &out, const ModelAnalyzer &ma, const Serializer &s) override;
};

} // namespace nnc

#endif //_NNC_SOFT_BACKEND_CPP_GENERATOR_H_