///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2020 Edouard Griffiths, F4EXB <f4exb06@gmail.com>               //
//                                                                               //
// Inspired by: https://github.com/myriadrf/LoRa-SDR                             //
//                                                                               //
// This program is free software; you can redistribute it and/or modify          //
// it under the terms of the GNU General Public License as published by          //
// the Free Software Foundation as version 3 of the License, or                  //
// (at your option) any later version.                                           //
//                                                                               //
// This program is distributed in the hope that it will be useful,               //
// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
// GNU General Public License V3 for more details.                               //
//                                                                               //
// You should have received a copy of the GNU General Public License             //
// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
///////////////////////////////////////////////////////////////////////////////////

#ifndef PLUGINS_CHANNELTX_MODMESHCORE_MESHCOREMODENCODERLORA_H_
#define PLUGINS_CHANNELTX_MODMESHCORE_MESHCOREMODENCODERLORA_H_

#include <vector>
#include <QByteArray>

class MeshcoreModEncoderLoRa
{
public:
    static void addChecksum(QByteArray& bytes);
    static void encodeBytes(
        const QByteArray& bytes,
        std::vector<unsigned short>& symbols,
        unsigned int payloadNbSymbolBits,
        unsigned int headerNbSymbolBits,
        bool hasHeader,
        bool hasCRC,
        unsigned int nbParityBits
    );

private:
    static constexpr unsigned int headerParityBits = 4;
    static constexpr unsigned int headerSymbols = 8;
    static constexpr unsigned int headerCodewords = 5;

    /***********************************************************************
     * Round functions
     **********************************************************************/
    static inline unsigned roundUp(unsigned num, unsigned factor)
    {
        return ((num + factor - 1) / factor) * factor;
    }

    /***********************************************************************
     * Standard LoRa Hamming(8,4) encode — LUT from gr4-lora hamming.hpp.
     * Matches the SX1262 hardware FEC decoder.  SDRangel's bit-level
     * Hamming_84sx uses a different parity matrix and produces
     * incompatible codewords.
     **********************************************************************/
    static inline unsigned char encodeHamming84sx(const unsigned char x)
    {
        // Standard LoRa Hamming(8,4) codewords per Semtech/LoRa spec.
        // Each 4-bit nibble maps to an 8-bit codeword (data + parity).
        static constexpr unsigned char kHammingCW[16] = {
            0, 23, 45, 58, 78, 89, 99, 116,
            139, 156, 166, 177, 197, 210, 232, 255
        };
        return kHammingCW[x & 0xf];
    }

    /***********************************************************************
     * Encode a 4 bit word into a 7 bits with parity.
     * Non standard version used in sx1272.
     **********************************************************************/
    static inline unsigned char encodeHamming74sx(const unsigned char x)
    {
        auto d0 = (x >> 0) & 0x1;
        auto d1 = (x >> 1) & 0x1;
        auto d2 = (x >> 2) & 0x1;
        auto d3 = (x >> 3) & 0x1;

        unsigned char b = x & 0xf;
        b |= (d0 ^ d1 ^ d2) << 4;
        b |= (d1 ^ d2 ^ d3) << 5;
        b |= (d0 ^ d1 ^ d3) << 6;
        return b;
    }

    /***********************************************************************
     * Encode a 4 bit word into a 6 bits with parity.
     **********************************************************************/
    static inline unsigned char encodeParity64(const unsigned char b)
    {
        auto x = b ^ (b >> 1) ^ (b >> 2);
        auto y = x ^ b ^ (b >> 3);
        return ((x & 1) << 4) | ((y & 1) << 5) | (b & 0xf);
    }

    /***********************************************************************
     * Encode a 4 bit word into a 5 bits with parity.
     **********************************************************************/
    static inline unsigned char encodeParity54(const unsigned char b)
    {
        auto x = b ^ (b >> 2);
        x = x ^ (x >> 1);
        return (b & 0xf) | ((x << 4) & 0x10);
    }

    /***********************************************************************
     *  CRC reverse engineered from Sx1272 data stream.
     *  Modified CCITT crc with masking of the output with an 8bit lfsr
     **********************************************************************/
    static inline uint16_t crc16sx(uint16_t crc, const uint16_t poly)
    {
        for (int i = 0; i < 8; i++)
        {
            if (crc & 0x8000) {
                crc = (crc << 1) ^ poly;
            } else {
                crc <<= 1;
            }
        }

        return crc;
    }

    static inline uint8_t xsum8(uint8_t t)
    {
        t ^= t >> 4;
        t ^= t >> 2;
        t ^= t >> 1;

        return (t & 1);
    }

    static inline uint16_t sx1272DataChecksum(const uint8_t *data, int length)
    {
        uint16_t res = 0;
        uint8_t v = 0xff;
        uint16_t crc = 0;

        for (int i = 0; i < length; i++)
        {
            crc = crc16sx(res, 0x1021);
            v = xsum8(v & 0xB8) | (v << 1);
            res = crc ^ data[i];
        }

        res ^= v;
        v = xsum8(v & 0xB8) | (v << 1);
        res ^= v << 8;

        return res;
    }

    /***********************************************************************
     * Specific checksum for header
     **********************************************************************/
    static inline uint8_t headerChecksum(const uint8_t *h)
    {
        auto a0 = (h[0] >> 4) & 0x1;
        auto a1 = (h[0] >> 5) & 0x1;
        auto a2 = (h[0] >> 6) & 0x1;
        auto a3 = (h[0] >> 7) & 0x1;

        auto b0 = (h[0] >> 0) & 0x1;
        auto b1 = (h[0] >> 1) & 0x1;
        auto b2 = (h[0] >> 2) & 0x1;
        auto b3 = (h[0] >> 3) & 0x1;

        auto c0 = (h[1] >> 0) & 0x1;
        auto c1 = (h[1] >> 1) & 0x1;
        auto c2 = (h[1] >> 2) & 0x1;
        auto c3 = (h[1] >> 3) & 0x1;

        uint8_t res;
        res = (a0 ^ a1 ^ a2 ^ a3) << 4;
        res |= (a3 ^ b1 ^ b2 ^ b3 ^ c0) << 3;
        res |= (a2 ^ b0 ^ b3 ^ c1 ^ c3) << 2;
        res |= (a1 ^ b0 ^ b2 ^ c0 ^ c1 ^ c2) << 1;
        res |= a0 ^ b1 ^ c0 ^ c1 ^ c2 ^ c3;

        return res;
    }

    /***********************************************************************
     * Standard LoRa whitening sequence (polynomial 0x21, 255 bytes).
     * Derived from the LoRa LFSR: x^9 + x^5 + 1, init 0x100.
     * Source: gr4-lora tables.hpp whitening_seq.
     **********************************************************************/
    static constexpr uint8_t kLoRaWhiteningSeq[255] = {
        0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE1, 0xC2, 0x85, 0x0B, 0x17, 0x2F, 0x5E, 0xBC, 0x78, 0xF1, 0xE3,
        0xC6, 0x8D, 0x1A, 0x34, 0x68, 0xD0, 0xA0, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x11, 0x23, 0x47,
        0x8E, 0x1C, 0x38, 0x71, 0xE2, 0xC4, 0x89, 0x12, 0x25, 0x4B, 0x97, 0x2E, 0x5C, 0xB8, 0x70, 0xE0,
        0xC0, 0x81, 0x03, 0x06, 0x0C, 0x19, 0x32, 0x64, 0xC9, 0x92, 0x24, 0x49, 0x93, 0x26, 0x4D, 0x9B,
        0x37, 0x6E, 0xDC, 0xB9, 0x72, 0xE4, 0xC8, 0x90, 0x20, 0x41, 0x82, 0x05, 0x0A, 0x15, 0x2B, 0x56,
        0xAD, 0x5B, 0xB6, 0x6D, 0xDA, 0xB5, 0x6B, 0xD6, 0xAC, 0x59, 0xB2, 0x65, 0xCB, 0x96, 0x2C, 0x58,
        0xB0, 0x61, 0xC3, 0x87, 0x0F, 0x1F, 0x3E, 0x7D, 0xFB, 0xF6, 0xED, 0xDB, 0xB7, 0x6F, 0xDE, 0xBD,
        0x7A, 0xF5, 0xEB, 0xD7, 0xAE, 0x5D, 0xBA, 0x74, 0xE8, 0xD1, 0xA2, 0x44, 0x88, 0x10, 0x21, 0x43,
        0x86, 0x0D, 0x1B, 0x36, 0x6C, 0xD8, 0xB1, 0x63, 0xC7, 0x8F, 0x1E, 0x3C, 0x79, 0xF3, 0xE7, 0xCE,
        0x9C, 0x39, 0x73, 0xE6, 0xCC, 0x98, 0x31, 0x62, 0xC5, 0x8B, 0x16, 0x2D, 0x5A, 0xB4, 0x69, 0xD2,
        0xA4, 0x48, 0x91, 0x22, 0x45, 0x8A, 0x14, 0x29, 0x52, 0xA5, 0x4A, 0x95, 0x2A, 0x54, 0xA9, 0x53,
        0xA7, 0x4E, 0x9D, 0x3B, 0x77, 0xEE, 0xDD, 0xBB, 0x76, 0xEC, 0xD9, 0xB3, 0x67, 0xCF, 0x9E, 0x3D,
        0x7B, 0xF7, 0xEF, 0xDF, 0xBF, 0x7E, 0xFD, 0xFA, 0xF4, 0xE9, 0xD3, 0xA6, 0x4C, 0x99, 0x33, 0x66,
        0xCD, 0x9A, 0x35, 0x6A, 0xD4, 0xA8, 0x51, 0xA3, 0x46, 0x8C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x07,
        0x0E, 0x1D, 0x3A, 0x75, 0xEA, 0xD5, 0xAA, 0x55, 0xAB, 0x57, 0xAF, 0x5F, 0xBE, 0x7C, 0xF9, 0xF2,
        0xE5, 0xCA, 0x94, 0x28, 0x50, 0xA1, 0x42, 0x84, 0x09, 0x13, 0x27, 0x4F, 0x9F, 0x3F, 0x7F
    };

    /// Apply standard LoRa nibble whitening to payload nibbles (not CRC).
    /// nibbles array contains 4-bit values per element. byteOffset is the
    /// starting byte index into the whitening sequence.
    static inline void loRaWhitenNibbles(uint8_t *nibbles, unsigned int count, unsigned int byteOffset)
    {
        for (unsigned int i = 0; i < count; i++) {
            unsigned int byteIdx = (byteOffset + i / 2) % 255;
            uint8_t mask = (i % 2 == 0)
                ? (kLoRaWhiteningSeq[byteIdx] & 0x0F)
                : ((kLoRaWhiteningSeq[byteIdx] >> 4) & 0x0F);
            nibbles[i] ^= mask;
        }
    }

    /***********************************************************************
     *  Whitening generator reverse engineered from Sx1272 data stream.
     *  Each bit of a codeword is combined with the output from a different position in the whitening sequence.
     **********************************************************************/
    static inline void Sx1272ComputeWhitening(uint8_t *buffer, uint16_t bufferSize, const int bitOfs, const int nbParityBits)
    {
        static const int ofs0[8] = {6,4,2,0,-112,-114,-302,-34 };	// offset into sequence for each bit
        static const int ofs1[5] = {6,4,2,0,-360 };					// different offsets used for single parity mode (1 == nbParityBits)
        static const int whiten_len = 510;							// length of whitening sequence
        static const uint64_t whiten_seq[8] = {						// whitening sequence
            0x0102291EA751AAFFL,0xD24B050A8D643A17L,0x5B279B671120B8F4L,0x032B37B9F6FB55A2L,
            0x994E0F87E95E2D16L,0x7CBCFC7631984C26L,0x281C8E4F0DAEF7F9L,0x1741886EB7733B15L
        };
        const int *ofs = (1 == nbParityBits) ? ofs1 : ofs0;
        int i, j;

        for (j = 0; j < bufferSize; j++)
        {
            uint8_t x = 0;

            for (i = 0; i < 4 + nbParityBits; i++)
            {
                int t = (ofs[i] + j + bitOfs + whiten_len) % whiten_len;

                if (whiten_seq[t >> 6] & ((uint64_t)1 << (t & 0x3F))) {
                    x |= 1 << i;
                }
            }

            buffer[j] ^= x;
        }
    }

    /***********************************************************************
     * Diagonal interleaver + deinterleaver
     **********************************************************************/
    static inline void diagonalInterleaveSx(
        const uint8_t *codewords,
        const size_t numCodewords,
        uint16_t *symbols,
        const size_t nbSymbolBits,
        const size_t nbParityBits
    )
    {
        for (size_t x = 0; x < numCodewords / nbSymbolBits; x++)
        {
            const size_t cwOff = x*nbSymbolBits;
            const size_t symOff = x*(4 + nbParityBits);

            for (size_t k = 0; k < 4 + nbParityBits; k++)
            {
                for (size_t m = 0; m < nbSymbolBits; m++)
                {
                    const size_t i = (k - m - 1 + nbSymbolBits) % nbSymbolBits;
                    const auto bit = (codewords[cwOff + i] >> k) & 0x1;
                    symbols[symOff + k] |= (bit << m);
                }
            }
        }
    }

    /***********************************************************************
     *  https://en.wikipedia.org/wiki/Gray_code
     **********************************************************************/

    /*
    * A more efficient version, for Gray codes of 16 or fewer bits.
    */
    static inline unsigned short grayToBinary16(unsigned short num)
    {
        num = num ^ (num >> 8);
        num = num ^ (num >> 4);
        num = num ^ (num >> 2);
        num = num ^ (num >> 1);
        return num;
    }
};

#endif // PLUGINS_CHANNELTX_MODMESHCORE_MESHCOREMODENCODERLORA_H_