using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataMatrix4Net
{
    public class ReedSolomon
    {
        const int NN = 255;
        const int MAX_ERROR_WORD_COUNT = 68;

        static byte[] log301 = new byte[]
        {
            255,   0,   1, 240,   2, 225, 241,  53,   3,  38, 226, 133, 242,  43,  54, 210,
              4, 195,  39, 114, 227, 106, 134,  28, 243, 140,  44,  23,  55, 118, 211, 234,
              5, 219, 196,  96,  40, 222, 115, 103, 228,  78, 107, 125, 135,   8,  29, 162,
            244, 186, 141, 180,  45,  99,  24,  49,  56,  13, 119, 153, 212, 199, 235,  91,
              6,  76, 220, 217, 197,  11,  97, 184,  41,  36, 223, 253, 116, 138, 104, 193,
            229,  86,  79, 171, 108, 165, 126, 145, 136,  34,   9,  74,  30,  32, 163,  84,
            245, 173, 187, 204, 142,  81, 181, 190,  46,  88, 100, 159,  25, 231,  50, 207,
             57, 147,  14,  67, 120, 128, 154, 248, 213, 167, 200,  63, 236, 110,  92, 176,
              7, 161,  77, 124, 221, 102, 218,  95, 198,  90,  12, 152,  98,  48, 185, 179,
             42, 209,  37, 132, 224,  52, 254, 239, 117, 233, 139,  22, 105,  27, 194, 113,
            230, 206,  87, 158,  80, 189, 172, 203, 109, 175, 166,  62, 127, 247, 146,  66,
            137, 192,  35, 252,  10, 183,  75, 216,  31,  83,  33,  73, 164, 144,  85, 170,
            246,  65, 174,  61, 188, 202, 205, 157, 143, 169,  82,  72, 182, 215, 191, 251,
             47, 178,  89, 151, 101,  94, 160, 123,  26, 112, 232,  21,  51, 238, 208, 131,
             58,  69, 148,  18,  15,  16,  68,  17, 121, 149, 129,  19, 155,  59, 249,  70,
            214, 250, 168,  71, 201, 156,  64,  60, 237, 130, 111,  20,  93, 122, 177, 150,
        };

        static byte[] antilog301 = new byte[]
        {
              1,   2,   4,   8,  16,  32,  64, 128,  45,  90, 180,  69, 138,  57, 114, 228,
            229, 231, 227, 235, 251, 219, 155,  27,  54, 108, 216, 157,  23,  46,  92, 184,
             93, 186,  89, 178,  73, 146,   9,  18,  36,  72, 144,  13,  26,  52, 104, 208,
            141,  55, 110, 220, 149,   7,  14,  28,  56, 112, 224, 237, 247, 195, 171, 123,
            246, 193, 175, 115, 230, 225, 239, 243, 203, 187,  91, 182,  65, 130,  41,  82,
            164, 101, 202, 185,  95, 190,  81, 162, 105, 210, 137,  63, 126, 252, 213, 135,
             35,  70, 140,  53, 106, 212, 133,  39,  78, 156,  21,  42,  84, 168, 125, 250,
            217, 159,  19,  38,  76, 152,  29,  58, 116, 232, 253, 215, 131,  43,  86, 172,
            117, 234, 249, 223, 147,  11,  22,  44,  88, 176,  77, 154,  25,  50, 100, 200,
            189,  87, 174, 113, 226, 233, 255, 211, 139,  59, 118, 236, 245, 199, 163, 107,
            214, 129,  47,  94, 188,  85, 170, 121, 242, 201, 191,  83, 166,  97, 194, 169,
            127, 254, 209, 143,  51, 102, 204, 181,  71, 142,  49,  98, 196, 165, 103, 206,
            177,  79, 158,  17,  34,  68, 136,  61, 122, 244, 197, 167,  99, 198, 161, 111,
            222, 145,  15,  30,  60, 120, 240, 205, 183,  67, 134,  33,  66, 132,  37,  74,
            148,   5,  10,  20,  40,  80, 160, 109, 218, 153,  31,  62, 124, 248, 221, 151,
              3,   6,  12,  24,  48,  96, 192, 173, 119, 238, 241, 207, 179,  75, 150,   0,
        };

        /// <summary>
        /// GF add (a + b)
        /// </summary>
        static byte GfAdd(byte a, byte b)
        {
            return (byte)(a ^ b);
        }

        /// <summary>
        /// GF multiply (a * b)
        /// </summary>
        static byte GfMult(byte a, byte b)
        {
            return (a == 0 || b == 0) ? (byte)0 : antilog301[(log301[a] + log301[b]) % NN];
        }

        /// <summary>
        /// GF multiply by antilog (a * alpha**b)
        /// </summary>
        static byte GfMultAntilog(byte a, byte b)
        {
            return (a == 0) ? (byte)0 : antilog301[(log301[a] + b) % NN];
        }


        /// <summary>
        /// Encode a byte array using Reed-Solomon error correction
        /// </summary>
        /// <param name="message">Input byte array</param>
        /// <param name="sizeId"></param>
        /// <returns>true when successful</returns>
        public static byte[] Encode(byte[] message, SymbolSize sizeId)
        {
            int blockStride = Symbol.GetSymbolAttribute(SymbolAttribute.InterleavedBlocks, sizeId);
            int blockErrorWords = Symbol.GetSymbolAttribute(SymbolAttribute.BlockErrorWords, sizeId);
            int symbolDataWords = Symbol.GetSymbolAttribute(SymbolAttribute.SymbolDataWords, sizeId);
            int symbolErrorWords = Symbol.GetSymbolAttribute(SymbolAttribute.SymbolErrorWords, sizeId);
            int symbolTotalWords = symbolDataWords + symbolErrorWords;

            byte[] output = new byte[symbolTotalWords];
            for (int i = 0; i < Math.Min(message.Length, symbolDataWords); i++)
            {
                output[i] = message[i];   /// Copy the original message to output
            }

            /// Populate generator polynomial
            byte[] gen = RsGenPoly(blockErrorWords);
        
            /// For each interleaved block...
            for (int blockIdx = 0; blockIdx < blockStride; blockIdx++)
            {
                /// Generate error codewords
                byte[] ecc = new byte[blockErrorWords];
                for (int i = 0; i < blockErrorWords; i++) ecc[i] = 0;
                
                for (int i = blockIdx; i < symbolDataWords; i += blockStride)
                {
                    byte val = (byte)(ecc[blockErrorWords - 1] ^ output[i]);
 
                    for (int j = blockErrorWords - 1; j > 0; j--)
                    {
                       //DMTX_CHECK_BOUNDS(&ecc, j); DMTX_CHECK_BOUNDS(&ecc, j-1); DMTX_CHECK_BOUNDS(&gen, j);
                       ecc[j] = GfAdd(ecc[j - 1], GfMult(gen[j], val));
                    }
 
                    ecc[0] = GfMult(gen[0], val);
                }
 
                /// Copy to output message
                int jj = blockErrorWords;
                for (int i = symbolDataWords + blockIdx; i < symbolTotalWords; i += blockStride)
                {
                    output[i] = ecc[--jj];
                }
            }
        
            return output;
        }


        static byte[] RsGenPoly(int errorWordCount)
        {
            byte[] gen = new byte[errorWordCount];

            /// Initialize all coefficients to 1
            for (int i = 0; i < errorWordCount; i++) gen[i] = (byte)1;
        
            /* Generate polynomial */
            for (int i = 0; i < gen.Length; i++)
            {
               for (int j = i; j >= 0; j--)
               {
                   gen[j] = GfMultAntilog(gen[j], (byte)(i + 1));
                   if (j > 0)
                   {
                       gen[j] = (byte)(gen[j] ^ gen[j - 1]);
                   }
               }
            }
      
            return gen;
        }
    }
}