/********************************************************************************
 * Copyright (c) 2023 CEA-List
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 ********************************************************************************/

#include "operator/BatchNormImpl.hpp"

#include <cassert>
#include <numeric>
#include <thread>
#include <vector>

#include "operator/BatchNormImpl_forward_kernels.hpp"
#include "operator/BatchNorm.hpp"
#include "utils/Types.h"

Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
    assert(mOp.getInput(inputIdx) && "requires valid input");

    // Requires the whole tensors
    const auto &inputDims = std::static_pointer_cast<Tensor>(mOp.getInput(inputIdx))->dims();

    return std::accumulate(inputDims.begin(), inputDims.end(), Aidge::NbElts_t(1), std::multiplies<NbElts_t>());
}

Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
    // for the direct convolution algorithm, convolutions can be in-place, if
    // there is no padding!
    return 0;
}

Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
                                                              const std::vector<Aidge::DimSize_t> &inputsSize) const {
    // Requires the whole tensors, regardless of available data on inputs
    assert(outputIdx == 0 && "operator has only one output");

    const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
    return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
}

Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbConsumedData(Aidge::IOIndex_t inputIdx) const {
    assert(static_cast<std::size_t>(inputIdx) < mNbConsumedData.size());
    return mNbConsumedData[static_cast<std::size_t>(inputIdx)];
}

Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbProducedData(Aidge::IOIndex_t outputIdx) const {
    assert((outputIdx == 0) && (static_cast<std::size_t>(outputIdx) < mNbProducedData.size()));
    return mNbProducedData[static_cast<std::size_t>(outputIdx)];
}

void Aidge::BatchNormImpl2D_cpu::forward() {
    // FIXME: uncomment the following code once memory handling will work
    assert(mOp.getInput(0) && "missing input #0");
    assert(mOp.getInput(1) && "missing input #1");
    assert(mOp.getInput(2) && "missing input #2");
    assert(mOp.getInput(3) && "missing input #3");
    assert(mOp.getInput(4) && "missing input #4");

    assert(mOp.getOutput(0)->nbDims() == 4);
    // Find the correct kernel type
    auto kernelFunc =
            Registrar<BatchNormImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getInput(1)->dataType(),
                                                          mOp.getOutput(0)->dataType()});

    // Call kernel
    kernelFunc(mOp.getParams(),
               mOp.getInput(0)->dims<4>(),
               mOp.getInput(0)->getImpl()->rawPtr(),
               mOp.getInput(1)->getImpl()->rawPtr(),
               mOp.getInput(2)->getImpl()->rawPtr(),
               mOp.getInput(3)->getImpl()->rawPtr(),
               mOp.getInput(4)->getImpl()->rawPtr(),
               mOp.getOutput(0)->getImpl()->rawPtr(),
               true);

    // Update producer-consumer data
    for (std::size_t inputIdx = 0; inputIdx < mNbConsumedData.size(); ++inputIdx)
        mNbConsumedData[inputIdx] += getNbRequiredData(static_cast<IOIndex_t>(inputIdx));  // each input is consumed by the minimum
                                                                   // amount for a forward pass

    mNbProducedData[0] += getRequiredMemory(0, {});
}

void Aidge::BatchNormImpl2D_cpu::backward() { printf("Not implemented yet.\n"); }