/**
 * @file
 *
 * @author  Mamadou Babaei <mamadou@senseglove.com>
 *
 * @section LICENSE
 *
 * (The MIT License)
 *
 * Copyright (c) 2020 - 2022 SenseGlove
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * @section DESCRIPTION
 *
 *
 */


#include "SGCoreImpl/SGHapticGloveQuickCalibrationImpl.h"

#include <string>
#include <vector>

#include "Containers/StringConv.h"
#include "Runtime/Launch/Resources/Version.h"

#include "SGBuildHacks/SGInclude_Core_HandPose.h"
#include "SGBuildHacks/SGInclude_Core_HapticGloveQuickCalibration.h"
#include "SGBuildHacks/SGInclude_Core_SensorRange.h"
#include "SGBuildHacks/SGInclude_Core_Vect3D.h"
#include "SGCoreImpl/SGHandPoseImpl.h"
#include "SGCoreImpl/SGHandProfileImpl.h"
#include "SGCoreImpl/SGHapticGloveImpl.h"
#include "SGCoreImpl/SGSensorRangeImpl.h"
#include "SGCoreImpl/SGVect3DImpl.h"
#include "SGUtils/SGArrayUtils.h"

struct FSGHapticGloveQuickCalibrationImpl::FImpl
{
    /************************
     * Member variables
     ************************/


    /************************
     * Owner object
     ************************/

    FSGHapticGloveQuickCalibrationImpl* Owner;

    /************************
     * Constructor / Destructor
     ************************/

    explicit FImpl(FSGHapticGloveQuickCalibrationImpl* InOwner);
    ~FImpl();

    /************************
     * Default copy constructor & copy assignment operator
     ************************/

    FImpl(const FImpl& Rhs) = default;
    FImpl& operator=(const FImpl& Rhs) = default;
};

float FSGHapticGloveQuickCalibrationImpl::GetDefaultAutoEndTimeout()
{
    static const float AutoEndTimeout = FHapticGloveQuickCalibrationType::GetDefaultAutoEndTimeout();
    return AutoEndTimeout;
}

FSGHapticGloveQuickCalibrationImpl::FSGHapticGloveQuickCalibrationImpl()
    : FSGHapticGloveCalibrationSequenceImpl(),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
{
}

FSGHapticGloveQuickCalibrationImpl::FSGHapticGloveQuickCalibrationImpl(
    const TSharedRef<FSGHapticGloveImpl> GloveToCalibrate, const float AutoEndTimeout)
    : FSGHapticGloveCalibrationSequenceImpl(
          MakeShared<FHapticGloveQuickCalibrationType>(GloveToCalibrate->ToHapticGlovePtr(), AutoEndTimeout)),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
{
}

FSGHapticGloveQuickCalibrationImpl::FSGHapticGloveQuickCalibrationImpl(
    const FHapticGloveQuickCalibrationType& HapticGloveQuickCalibration)
    : FSGHapticGloveCalibrationSequenceImpl(MakeShared<FHapticGloveQuickCalibrationType>(HapticGloveQuickCalibration)),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
{
}

FSGHapticGloveQuickCalibrationImpl::FSGHapticGloveQuickCalibrationImpl(const FSGHapticGloveQuickCalibrationImpl& Rhs)
    :
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
#else
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
{
    Pimpl->Owner = this;
}

FSGHapticGloveQuickCalibrationImpl::FSGHapticGloveQuickCalibrationImpl(
    FSGHapticGloveQuickCalibrationImpl&& Rhs)
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
    noexcept
#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
    = default;

FSGHapticGloveQuickCalibrationImpl::~FSGHapticGloveQuickCalibrationImpl() = default;

FSGHapticGloveQuickCalibrationImpl& FSGHapticGloveQuickCalibrationImpl::operator=(
    const FSGHapticGloveQuickCalibrationImpl& Rhs)
{
    *Pimpl = *Rhs.Pimpl;
    Pimpl->Owner = this;
    return *this;
}

FSGHapticGloveQuickCalibrationImpl& FSGHapticGloveQuickCalibrationImpl::operator=(
    FSGHapticGloveQuickCalibrationImpl&& Rhs)
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
    noexcept
#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
    = default;

const FSGHapticGloveQuickCalibrationImpl::FHapticGloveQuickCalibrationType&
FSGHapticGloveQuickCalibrationImpl::ToHapticGloveQuickCalibration() const
{
    return *StaticCastSharedRef<FHapticGloveQuickCalibrationType>(ToHapticGloveCalibrationSequenceRef());
}

TSharedRef<FSGHapticGloveQuickCalibrationImpl::FHapticGloveQuickCalibrationType> FSGHapticGloveQuickCalibrationImpl::
ToHapticGloveQuickCalibrationRef() const
{
    return StaticCastSharedRef<FHapticGloveQuickCalibrationType>(ToHapticGloveCalibrationSequenceRef());
}

float FSGHapticGloveQuickCalibrationImpl::GetAutoEndTimeout() const
{
    return ToHapticGloveQuickCalibrationRef()->GetAutoEndTimeout();
}

void FSGHapticGloveQuickCalibrationImpl::SetAutoEndTimeout(const float AutoEndTimeout)
{
    ToHapticGloveQuickCalibrationRef()->SetAutoEndTimeout(AutoEndTimeout);
}

int32 FSGHapticGloveQuickCalibrationImpl::GetSmoothingSamples() const
{
    return ToHapticGloveQuickCalibrationRef()->GetSmoothingSamples();
}

FSGSensorRangeImpl FSGHapticGloveQuickCalibrationImpl::GetSensorRange() const
{
    const FSGSensorRangeImpl SensorRange{ToHapticGloveQuickCalibrationRef()->GetSensorRange()};
    return SensorRange;
}

FSGHandProfileImpl FSGHapticGloveQuickCalibrationImpl::GetTemporaryProfile() const
{
    const FSGHandProfileImpl TemporaryProfile{ToHapticGloveQuickCalibrationRef()->GetTemporaryProfile()};
    return TemporaryProfile;
}

bool FSGHapticGloveQuickCalibrationImpl::CanAnimate() const
{
    return ToHapticGloveQuickCalibrationRef()->CanAnimate();
}

bool FSGHapticGloveQuickCalibrationImpl::AutoCompleted() const
{
    return ToHapticGloveQuickCalibrationRef()->AutoCompleted();
}

void FSGHapticGloveQuickCalibrationImpl::Reset()
{
    ToHapticGloveQuickCalibrationRef()->Reset();
}

void FSGHapticGloveQuickCalibrationImpl::Update(const float DeltaSeconds)
{
    return ToHapticGloveQuickCalibrationRef()->Update(DeltaSeconds);
}

void FSGHapticGloveQuickCalibrationImpl::AddDataPoint(const TArray<FVector>& CalibrationData)
{
    std::vector<FSGVect3DImpl::FVect3DType> CalibrationDataVector{
        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
            CalibrationData)
    };
    ToHapticGloveQuickCalibrationRef()->AddDataPoint(MoveTemp(CalibrationDataVector));
}

void FSGHapticGloveQuickCalibrationImpl::ConfirmCurrentStep()
{
    ToHapticGloveQuickCalibrationRef()->ConfirmCurrentStep();
}

bool FSGHapticGloveQuickCalibrationImpl::CompileRange(FSGSensorRangeImpl& OutSensorRange) const
{
    FSGSensorRangeImpl::FSensorRangeType SensorRange;
    const bool bResult = ToHapticGloveQuickCalibrationRef()->CompileRange(SensorRange);
    OutSensorRange = FSGSensorRangeImpl{SensorRange};
    return bResult;
}

bool FSGHapticGloveQuickCalibrationImpl::GetHandPose(const bool bRightHanded, FSGHandPoseImpl& OutCurrentHandPose) const
{
    FSGHandPoseImpl::FHandPoseType CurrentHandPose;
    const bool bResult = ToHapticGloveQuickCalibrationRef()->GetHandPose(bRightHanded, CurrentHandPose);
    OutCurrentHandPose = FSGHandPoseImpl{CurrentHandPose};
    return bResult;
}

FString FSGHapticGloveQuickCalibrationImpl::GetCurrentInstruction(const FString& NextStepKey) const
{
    std::string NextStepKeyString{TCHAR_TO_UTF8(*NextStepKey)};
    const FString CurrentInstruction{TCHAR_TO_UTF8(ToHapticGloveQuickCalibrationRef()->GetCurrentInstruction(
        MoveTemp(NextStepKeyString)).c_str())};
    return CurrentInstruction;
}

FSGHapticGloveQuickCalibrationImpl::FImpl::FImpl(FSGHapticGloveQuickCalibrationImpl* InOwner)
    : Owner(InOwner)
{
}

FSGHapticGloveQuickCalibrationImpl::FImpl::~FImpl() = default;

void FSGHapticGloveQuickCalibrationImpl::FImplDeleter::operator()(const FImpl* P) const
{
    delete P;
}