//==================================================================================
// BSD 2-Clause License
//
// Copyright (c) 2014-2022, NJIT, Duality Technologies Inc. and other contributors
//
// All rights reserved.
//
// Author TPOC: contact@openfhe.org
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//==================================================================================

/*
BGV implementation. See https://eprint.iacr.org/2021/204 for details.
 */

#define PROFILE

#include "ciphertext.h"
#include "scheme/bgvrns/bgvrns-cryptoparameters.h"
#include "scheme/bgvrns/bgvrns-leveledshe.h"

namespace lbcrypto {

void LeveledSHEBGVRNS::ModReduceInternalInPlace(Ciphertext<DCRTPoly>& ciphertext, size_t levels) const {
    const auto cryptoParams = std::dynamic_pointer_cast<CryptoParametersBGVRNS>(ciphertext->GetCryptoParameters());

    const auto t = ciphertext->GetCryptoParameters()->GetPlaintextModulus();

    auto& cv      = ciphertext->GetElements();
    size_t sizeQl = cv[0].GetNumOfElements();

    if (sizeQl > levels && sizeQl > 0) {
        for (auto& c : cv) {
            for (size_t i = sizeQl - 1; i >= sizeQl - levels; --i) {
                c.ModReduce(t, cryptoParams->GettModqPrecon(), cryptoParams->GetNegtInvModq(i),
                            cryptoParams->GetNegtInvModqPrecon(i), cryptoParams->GetqlInvModq(i),
                            cryptoParams->GetqlInvModqPrecon(i));
            }
        }
    }
    else {
        OPENFHE_THROW("Too few towers to support ModReduce.");
    }

    ciphertext->SetLevel(ciphertext->GetLevel() + levels);
    ciphertext->SetNoiseScaleDeg(ciphertext->GetNoiseScaleDeg() - levels);

    if (cryptoParams->GetScalingTechnique() == FLEXIBLEAUTO || cryptoParams->GetScalingTechnique() == FLEXIBLEAUTOEXT) {
        for (size_t i = 0; i < levels; ++i) {
            NativeInteger modReduceFactor    = cryptoParams->GetModReduceFactorInt(sizeQl - 1 - i);
            NativeInteger modReduceFactorInv = modReduceFactor.ModInverse(t);
            ciphertext->SetScalingFactorInt(ciphertext->GetScalingFactorInt().ModMul(modReduceFactorInv, t));
        }
    }
}

void LeveledSHEBGVRNS::LevelReduceInternalInPlace(Ciphertext<DCRTPoly>& ciphertext, size_t levels) const {
    for (auto& e : ciphertext->GetElements())
        e.DropLastElements(levels);
    ciphertext->SetLevel(ciphertext->GetLevel() + levels);
}

void LeveledSHEBGVRNS::AdjustLevelsAndDepthInPlace(Ciphertext<DCRTPoly>& ciphertext1,
                                                   Ciphertext<DCRTPoly>& ciphertext2) const {
    const auto cryptoParams = std::dynamic_pointer_cast<CryptoParametersBGVRNS>(ciphertext1->GetCryptoParameters());

    const NativeInteger t(cryptoParams->GetPlaintextModulus());

    uint32_t c1lvl   = ciphertext1->GetLevel();
    uint32_t c2lvl   = ciphertext2->GetLevel();
    uint32_t c1depth = ciphertext1->GetNoiseScaleDeg();
    uint32_t c2depth = ciphertext2->GetNoiseScaleDeg();
    auto sizeQl1     = ciphertext1->GetElements()[0].GetNumOfElements();
    auto sizeQl2     = ciphertext2->GetElements()[0].GetNumOfElements();

    if (c1lvl < c2lvl) {
        if (c1depth == 2) {
            if (c2depth == 2) {
                NativeInteger scf1    = ciphertext1->GetScalingFactorInt();
                NativeInteger scf2    = ciphertext2->GetScalingFactorInt();
                NativeInteger ql1Modt = cryptoParams->GetModReduceFactorInt(sizeQl1 - 1);
                NativeInteger scf1Inv = scf1.ModInverse(t);

                EvalMultCoreInPlace(ciphertext1, scf2.ModMul(scf1Inv, t).ModMul(ql1Modt, t).ConvertToInt());
                ModReduceInternalInPlace(ciphertext1, BASE_NUM_LEVELS_TO_DROP);
                if (c1lvl + 1 < c2lvl) {
                    LevelReduceInternalInPlace(ciphertext1, c2lvl - c1lvl - 1);
                }
                ciphertext1->SetScalingFactorInt(ciphertext2->GetScalingFactorInt());
            }
            else {
                if (c1lvl + 1 == c2lvl) {
                    ModReduceInternalInPlace(ciphertext1, BASE_NUM_LEVELS_TO_DROP);
                }
                else {
                    NativeInteger scf1    = ciphertext1->GetScalingFactorInt();
                    NativeInteger scf2    = cryptoParams->GetScalingFactorIntBig(c2lvl - 1);
                    NativeInteger ql1Modt = cryptoParams->GetModReduceFactorInt(sizeQl1 - 1);
                    NativeInteger scf1Inv = scf1.ModInverse(t);

                    EvalMultCoreInPlace(ciphertext1, scf2.ModMul(scf1Inv, t).ModMul(ql1Modt, t).ConvertToInt());
                    ModReduceInternalInPlace(ciphertext1, BASE_NUM_LEVELS_TO_DROP);
                    if (c1lvl + 2 < c2lvl) {
                        LevelReduceInternalInPlace(ciphertext1, c2lvl - c1lvl - 2);
                    }
                    ModReduceInternalInPlace(ciphertext1, BASE_NUM_LEVELS_TO_DROP);
                    ciphertext1->SetScalingFactorInt(ciphertext2->GetScalingFactorInt());
                }
            }
        }
        else {
            if (c2depth == 2) {
                NativeInteger scf1    = ciphertext1->GetScalingFactorInt();
                NativeInteger scf2    = ciphertext2->GetScalingFactorInt();
                NativeInteger scf1Inv = scf1.ModInverse(t);

                EvalMultCoreInPlace(ciphertext1, scf2.ModMul(scf1Inv, t).ConvertToInt());
                LevelReduceInternalInPlace(ciphertext1, c2lvl - c1lvl);
                ciphertext1->SetScalingFactorInt(scf2);
            }
            else {
                NativeInteger scf1    = ciphertext1->GetScalingFactorInt();
                NativeInteger scf2    = cryptoParams->GetScalingFactorIntBig(c2lvl - 1);
                NativeInteger scf1Inv = scf1.ModInverse(t);

                EvalMultCoreInPlace(ciphertext1, scf2.ModMul(scf1Inv, t).ConvertToInt());
                if (c1lvl + 1 < c2lvl) {
                    LevelReduceInternalInPlace(ciphertext1, c2lvl - c1lvl - 1);
                }
                ModReduceInternalInPlace(ciphertext1, BASE_NUM_LEVELS_TO_DROP);
                ciphertext1->SetScalingFactorInt(ciphertext2->GetScalingFactorInt());
            }
        }
    }
    else if (c1lvl > c2lvl) {
        if (c2depth == 2) {
            if (c1depth == 2) {
                NativeInteger scf2    = ciphertext2->GetScalingFactorInt();
                NativeInteger scf1    = ciphertext1->GetScalingFactorInt();
                NativeInteger ql2Modt = cryptoParams->GetModReduceFactorInt(sizeQl2 - 1);
                NativeInteger scf2Inv = scf2.ModInverse(t);

                EvalMultCoreInPlace(ciphertext2, scf1.ModMul(scf2Inv, t).ModMul(ql2Modt, t).ConvertToInt());
                ModReduceInternalInPlace(ciphertext2, BASE_NUM_LEVELS_TO_DROP);
                if (c2lvl + 1 < c1lvl) {
                    LevelReduceInternalInPlace(ciphertext2, c1lvl - c2lvl - 1);
                }
                ciphertext2->SetScalingFactorInt(ciphertext1->GetScalingFactorInt());
            }
            else {
                if (c2lvl + 1 == c1lvl) {
                    ModReduceInternalInPlace(ciphertext2, BASE_NUM_LEVELS_TO_DROP);
                }
                else {
                    NativeInteger scf2    = ciphertext2->GetScalingFactorInt();
                    NativeInteger scf1    = cryptoParams->GetScalingFactorIntBig(c1lvl - 1);
                    NativeInteger ql2Modt = cryptoParams->GetModReduceFactorInt(sizeQl2 - 1);
                    NativeInteger scf2Inv = scf2.ModInverse(t);

                    EvalMultCoreInPlace(ciphertext2, scf1.ModMul(scf2Inv, t).ModMul(ql2Modt, t).ConvertToInt());
                    ModReduceInternalInPlace(ciphertext2, BASE_NUM_LEVELS_TO_DROP);
                    if (c2lvl + 2 < c1lvl) {
                        LevelReduceInternalInPlace(ciphertext2, c1lvl - c2lvl - 2);
                    }
                    ModReduceInternalInPlace(ciphertext2, BASE_NUM_LEVELS_TO_DROP);
                    ciphertext2->SetScalingFactorInt(ciphertext1->GetScalingFactorInt());
                }
            }
        }
        else {
            if (c1depth == 2) {
                NativeInteger scf2    = ciphertext2->GetScalingFactorInt();
                NativeInteger scf1    = ciphertext1->GetScalingFactorInt();
                NativeInteger scf2Inv = scf2.ModInverse(t);

                EvalMultCoreInPlace(ciphertext2, scf1.ModMul(scf2Inv, t).ConvertToInt());
                LevelReduceInternalInPlace(ciphertext2, c1lvl - c2lvl);
                ciphertext2->SetScalingFactorInt(scf1);
            }
            else {
                NativeInteger scf2    = ciphertext2->GetScalingFactorInt();
                NativeInteger scf1    = cryptoParams->GetScalingFactorIntBig(c1lvl - 1);
                NativeInteger scf2Inv = scf2.ModInverse(t);

                EvalMultCoreInPlace(ciphertext2, scf1.ModMul(scf2Inv, t).ConvertToInt());
                if (c2lvl + 1 < c1lvl) {
                    LevelReduceInternalInPlace(ciphertext2, c1lvl - c2lvl - 1);
                }
                ModReduceInternalInPlace(ciphertext2, BASE_NUM_LEVELS_TO_DROP);
                ciphertext2->SetScalingFactorInt(ciphertext1->GetScalingFactorInt());
            }
        }
    }
    else {
        if (c1depth < c2depth) {
            NativeInteger scf = ciphertext1->GetScalingFactorInt();
            EvalMultCoreInPlace(ciphertext1, scf.ConvertToInt());
        }
        else if (c2depth < c1depth) {
            NativeInteger scf = ciphertext2->GetScalingFactorInt();
            EvalMultCoreInPlace(ciphertext2, scf.ConvertToInt());
        }
    }
}

void LeveledSHEBGVRNS::AdjustLevelsAndDepthToOneInPlace(Ciphertext<DCRTPoly>& ciphertext1,
                                                        Ciphertext<DCRTPoly>& ciphertext2) const {
    AdjustLevelsAndDepthInPlace(ciphertext1, ciphertext2);
    if (ciphertext1->GetNoiseScaleDeg() == 2) {
        ModReduceInternalInPlace(ciphertext1, BASE_NUM_LEVELS_TO_DROP);
        ModReduceInternalInPlace(ciphertext2, BASE_NUM_LEVELS_TO_DROP);
    }
}

void LeveledSHEBGVRNS::EvalMultCoreInPlace(Ciphertext<DCRTPoly>& ciphertext, NativeInteger scalar) const {
    const auto cryptoParams = std::dynamic_pointer_cast<CryptoParametersBGVRNS>(ciphertext->GetCryptoParameters());

    auto& cv = ciphertext->GetElements();
    for (uint32_t i = 0; i < cv.size(); ++i)
        cv[i] *= scalar;

    const NativeInteger t(cryptoParams->GetPlaintextModulus());
    ciphertext->SetNoiseScaleDeg(ciphertext->GetNoiseScaleDeg() + 1);
    if (cryptoParams->GetScalingTechnique() == FLEXIBLEAUTO || cryptoParams->GetScalingTechnique() == FLEXIBLEAUTOEXT) {
        ciphertext->SetScalingFactorInt(ciphertext->GetScalingFactorInt().ModMul(scalar, t));
    }
}

void LeveledSHEBGVRNS::EvalMultInPlace(Ciphertext<DCRTPoly>& ciphertext, ConstPlaintext& plaintext) const {
    LeveledSHERNS::EvalMultInPlace(ciphertext, plaintext);
    const auto cryptoParams = std::dynamic_pointer_cast<CryptoParametersBGVRNS>(ciphertext->GetCryptoParameters());
    if (cryptoParams->GetScalingTechnique() == FLEXIBLEAUTO || cryptoParams->GetScalingTechnique() == FLEXIBLEAUTOEXT) {
        const auto plainMod = ciphertext->GetCryptoParameters()->GetPlaintextModulus();
        ciphertext->SetScalingFactorInt(
            ciphertext->GetScalingFactorInt().ModMul(ciphertext->GetScalingFactorInt(), plainMod));
    }
}

uint32_t LeveledSHEBGVRNS::FindAutomorphismIndex(uint32_t index, uint32_t m) const {
    return FindAutomorphismIndex2n(index, m);
}

}  // namespace lbcrypto
