#pragma once

#include "daal.h"
#include "algorithms/optimization_solver/objective_function/logistic_loss_types.h"

#include "algorithms/optimization_solver/objective_function/logistic_loss_batch.h"

using namespace daal;
using namespace daal::algorithms::optimization_solver;

namespace logistic_prox_function
{
	template<typename algorithmFPType, logistic_loss::Method method, CpuType cpu>
	class BatchContainer : public logistic_loss::BatchContainer<algorithmFPType, method, cpu>
	{
	public:
		
		BatchContainer(daal::services::Environment::env* daalEnv) :logistic_loss::BatchContainer<algorithmFPType, method, cpu>(daalEnv) {};
		/** Default destructor */
		virtual ~BatchContainer() {};
		virtual services::Status compute() DAAL_C11_OVERRIDE;
	};

	template<typename algorithmFPType, logistic_loss::Method method, CpuType cpu>
	daal::services::Status BatchContainer<algorithmFPType, method, cpu>::compute()
	{
		return daal::services::Status();
	}

	template<typename algorithmFPType = DAAL_ALGORITHM_FP_TYPE, logistic_loss::Method method = logistic_loss::defaultDense>
	class Batch : public logistic_loss::Batch<float, method>
	{
	public:
		typedef logistic_loss::Batch<float, method> super;
		typedef algorithms::optimization_solver::logistic_loss::Input     InputType;
		typedef algorithms::optimization_solver::logistic_loss::Parameter ParameterType;
		typedef typename super::ResultType                                ResultType;

		/**
		 *  Main constructor
		 */
		Batch(size_t numberOfTerms) : logistic_loss::Batch<float, method>(numberOfTerms)
		{
			initialize();
		}

		virtual ~Batch() {}

		Batch(const Batch<algorithmFPType, method>& other) :
			logistic_loss::Batch<float, method>(other)
		{
			initialize();
		}

		virtual int getMethod() const DAAL_C11_OVERRIDE { return(int)method; }

		services::SharedPtr<Batch<algorithmFPType, method> > clone() const
		{
			return services::SharedPtr<Batch<algorithmFPType, method> >(cloneImpl());
		}

		services::Status allocate()
		{
			return allocateResult();
		}

		ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }

		const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }


		//static services::SharedPtr<Batch<algorithmFPType, method> > create(size_t numberOfTerms);

	protected:
		//virtual Batch<algorithmFPType, method>* cloneImpl() const DAAL_C11_OVERRIDE
		//{
		//	return new Batch<algorithmFPType, method>(*this);
		//}

		//virtual services::Status allocateResult() DAAL_C11_OVERRIDE
		//{
		//	services::Status s = _result->allocate<algorithmFPType>(&input, _par, (int)method);
		//	_res = _result.get();
		//	return s;
		//}

		void initialize()
		{
			//Analysis<batch>::_ac = new __DAAL_ALGORITHM_CONTAINER(batch, BatchContainer, algorithmFPType, method)(&_env);
			Analysis<batch>::_ac = new BatchContainer<algorithmFPType, method, CpuType::sse2>(&_env);
			_in = &input;
			_par = sumOfFunctionsParameter;
		}

	public:
		//InputType input;           /*!< %Input data structure */
	};
	/** @} */
}