// SPDX-License-Identifier: MIT
#include "MParameter.hh"

#include <ostream>
#include <utility>

std::string StorageType( const Parameter &parameter )
{
  return "std::decay_t< " + parameter.Type + " >";
}

//
// ParameterWriter
//
ParameterWriter::ParameterWriter( std::ostream &stream, std::string &indent,
                                  bool separator, bool maybeUnused )
  : Writer( stream, indent ),
    _Separator( separator ),
    _MaybeUnused( maybeUnused )
{
  // blank
}

void ParameterWriter::operator( )( const Parameter &parameter )
{
  if ( _Separator )
  {
    _Stream << ',' << std::endl << _Indent;
  }
  else
  {
    _Separator = true;
  }

  if ( _MaybeUnused )
  {
    _Stream << "[[maybe_unused]] ";
  }

  _Stream << parameter.Type << ' ' << parameter.Name;
}

//
// ParameterToVariableWriter
//
ParameterToVariableWriter::ParameterToVariableWriter( std::ostream &stream, std::string &indent )
  : Writer( stream, indent )
{
  // blank
}

void ParameterToVariableWriter::operator( )( const Parameter &parameter )
{
  _Stream << _Indent << StorageType( parameter ) << " member_" << parameter.Name << ';' << std::endl;
}

//
// ParameterToGetterWriter
//
ParameterToGetterWriter::ParameterToGetterWriter( std::ostream &stream, std::string &indent )
  : Writer( stream, indent )
{
  // blank
}

void ParameterToGetterWriter::operator( )( const Parameter &parameter )
{
  _Stream << _Indent << StorageType( parameter ) << " const &" << parameter.Name
          << "( ) const" << std::endl
          << _Indent << '{' << std::endl;
  right( );
  _Stream << _Indent << "return member_" << parameter.Name << ';' << std::endl;
  left( );
  _Stream << _Indent << '}' << std::endl << std::endl;
}

//
// ParameterVariableConstructorWriter
//
ParameterVariableConstructorWriter::ParameterVariableConstructorWriter( std::ostream &stream, std::string &indent,
                                                                        bool separator )
  : Writer( stream, indent ),
    _Separator( separator )
{
  // blank
}

void ParameterVariableConstructorWriter::operator( )( const Parameter &parameter )
{
  if ( _Separator )
  {
    _Stream << ',' << std::endl << _Indent;
  }
  else
  {
    _Separator = true;
  }

  _Stream << "member_" << parameter.Name << "( " << parameter.Name << " )";
}

//
// ParameterCallWriter
//
ParameterCallWriter::ParameterCallWriter( std::ostream &stream, std::string &indent,
                                          std::string memberPrefix, bool separator )
  : Writer( stream, indent ),
    _MemberPrefix( std::move( memberPrefix ) ),
    _Separator( separator )
{
  // blank
}

void ParameterCallWriter::operator( )( const Parameter &parameter )
{
  if ( _Separator )
  {
    _Stream << ", ";
  }
  else
  {
    _Separator = true;
  }

  _Stream << _MemberPrefix << parameter.Name;
}