#include <gtest/gtest.h>

#include "Function3D.h"
#include "transmissionReconstruction/dataPreperation.h"

inline float fourDecimalRound(float src){
    return round(src*10000.0)/10000.0;
}

#define EXPECT_FLOAT_AE(valueA,valueB)\
    EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))

class TransRecon_DataPreperation_Test : public ::testing::Test {
protected:
    static void SetUpTransRecon_DataPreperationTester() {

    }

    static void TearDownTestCase() {
    }

    void SetUp() {
    }

    void TearDown() {
    }
};

TEST_F(TransRecon_DataPreperation_Test, distanceBetweenTwoPoints) {
        float *dataA = new float[9]{1, 9, 4, 0, .01, 1.9, 300,22, -93};
        auto A = Aurora::Matrix::fromRawData(dataA, 3, 3);
        float *dataB = new float[9]{2,3,3,2,2,1,3,3,-3};
        auto B = Aurora::Matrix::fromRawData(dataB, 3, 3);
        auto output =Recon::distanceBetweenTwoPoints(B,A);
        EXPECT_EQ(3, output.getDataSize());
        EXPECT_FLOAT_AE(6.1644,output.getData()[0]);
        EXPECT_FLOAT_AE(2.9614,output.getData()[1]);
        EXPECT_FLOAT_AE(310.9180,output.getData()[2]);
}

TEST_F(TransRecon_DataPreperation_Test, calculateWaterTemperature) {

        auto waterTempS = Aurora::ones(3, 2) * 25.9;
        auto waterTempR = Aurora::ones(4, 2) * 20 + 1.1;
        float *xD = new float[6]{1, 2, 3, 1, 2, 3};
        Aurora::Matrix sl(
            std::shared_ptr<float>(xD, std::default_delete<float[]>()),
            std::vector<int>{6});
        xD = new float[6]{1, 1, 1, 1, 1, 1};
        Aurora::Matrix rl(
            std::shared_ptr<float>(xD, std::default_delete<float[]>()),
            std::vector<int>{6});
        xD = new float[6]{1, 1, 1, 2, 2, 2};
        Aurora::Matrix mp(
            std::shared_ptr<float>(xD, std::default_delete<float[]>()),
            std::vector<int>{6});

        auto output = Recon::calculateWaterTemperature(waterTempS, waterTempR,
                                                       sl, rl, mp);
        EXPECT_EQ(6, output.getDataSize());
        EXPECT_FLOAT_AE(23.5, output.getData()[0]);
        EXPECT_FLOAT_AE(23.5, output.getData()[1]);
}

TEST_F(TransRecon_DataPreperation_Test, prepareAScansForTransmissionDetection){
        auto aScanBlock = Aurora::ones(300, 10) * 21.1;
        auto gainBlock = Aurora::ones(1, 10) * 20 + 66.6;
        auto result = Recon::prepareAScansForTransmissionDetection(aScanBlock,gainBlock);
        EXPECT_EQ(300, result.getDimSize(0));
        EXPECT_EQ(10, result.getDimSize(1));
        EXPECT_FLOAT_AE(0, result.getData()[0]);
}