/// <summary>
        ///
        /// </summary>
        /// <param name="content"></param>
        /// <param name="ecLevel"></param>
        /// <param name="hints"></param>
        /// <param name="qrCode"></param>
        public static void encode(System.String content, ErrorCorrectionLevel ecLevel,
                                  IDictionary <EncodeHintType, object> hints, MicroQRCode qrCode, int versionNum)
        {
            if (versionNum < 1 || versionNum > 4)
            {
                throw new ArgumentOutOfRangeException("versionNum", "versionNum [1, 4]");
            }
            System.String encoding = null;
            if (hints.ContainsKey(EncodeHintType.CHARACTER_SET))
            {
                encoding = hints == null ? null : (System.String)hints[EncodeHintType.CHARACTER_SET];
                if (encoding == null)
                {
                    encoding = DEFAULT_BYTE_MODE_ENCODING;
                }
            }

            // Step 1: Choose the mode (encoding).
            Mode mode = chooseMode(content, encoding);

            // Step 2: Append "bytes" into "dataBits" in appropriate encoding.
            BitVector dataBits = new BitVector();

            appendBytes(content, mode, dataBits, encoding, versionNum);
            // Step 3: Initialize QR code that can contain "dataBits".
            int numInputBytes = dataBits.sizeInBytes();

            initQRCode(numInputBytes, ecLevel, mode, qrCode, versionNum);

            // Step 4: Build another bit vector that contains header and data.
            BitVector headerAndDataBits = new BitVector();

            //INFO ECB+Mode+Length+Data[+terminate]
            // Step 4.5: Append ECI message if applicable
            appendModeInfo(mode, headerAndDataBits, versionNum);
            int numLetters = mode.Equals(Mode.BYTE) ? dataBits.sizeInBytes() : content.Length;

            appendLengthInfo(numLetters, qrCode.Version, mode, headerAndDataBits);
            headerAndDataBits.appendBitVector(dataBits);

            // Step 5: Terminate the bits properly.
            terminateBits(qrCode.NumDataBytes, headerAndDataBits, versionNum);

            // Step 6: Interleave data bits with error correction code.
            BitVector finalBits = new BitVector();

            interleaveWithECBytes(headerAndDataBits, versionNum, qrCode.NumTotalBytes, qrCode.NumDataBytes, qrCode.NumRSBlocks, finalBits);

            // Step 7: Choose the mask pattern and set to "qrCode".
            ByteMatrix matrix = new ByteMatrix(qrCode.MatrixWidth, qrCode.MatrixWidth);

            qrCode.MaskPattern = chooseMaskPattern(finalBits, qrCode.ECLevel, qrCode.Version, matrix);

            // Step 8.  Build the matrix and set it to "qrCode".
            MatrixUtil.buildMatrix(finalBits, qrCode.ECLevel, qrCode.Version, qrCode.MaskPattern, matrix);
            qrCode.Matrix = matrix;

            //var decoder = new com.google.zxing.microqrcode.decoder.Decoder();
            //var res = decoder.decode(com.google.zxing.common.BitMatrix.FromByteMatrix(matrix));
            //Console.WriteLine(res.Text);

            // Step 9.  Make sure we have a valid QR Code.
            if (!qrCode.Valid)
            {
                throw new WriterException("Invalid QR code: " + qrCode.ToString());
            }
        }
        /// <summary> Append length info. On success, store the result in "bits".</summary>
        internal static void appendLengthInfo(int numLetters, int version, Mode mode, BitVector bits)
        {
            int numBits = mode.getCharacterCountBits(Version.getVersionForNumber(version));

            if (numLetters > ((1 << numBits) - 1))
            {
                throw new WriterException(numLetters + "is bigger than" + ((1 << numBits) - 1));
            }
            bits.appendBits(numLetters, numBits);
        }
        /// <summary> Interleave "bits" with corresponding error correction bytes. On success, store the result in
        /// "result". The interleave rule is complicated. See 8.6 of JISX0510:2004 (p.37) for details.
        /// </summary>
        internal static void interleaveWithECBytes(BitVector bits, int versionNum, int numTotalBytes, int numDataBytes, int numRSBlocks, BitVector result)
        {
            // "bits" must have "getNumDataBytes" bytes of data.
            if (bits.sizeInBytes() != numDataBytes)
            {
                throw new WriterException("Number of bits and data bytes does not match");
            }

            // Step 1.  Divide data bytes into blocks and generate error correction bytes for them. We'll
            // store the divided data bytes blocks and error correction bytes blocks into "blocks".
            int dataBytesOffset = 0;
            int maxNumDataBytes = 0;
            int maxNumEcBytes   = 0;

            // Since, we know the number of reedsolmon blocks, we can initialize the vector with the number.
            System.Collections.ArrayList blocks = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(numRSBlocks));

            for (int i = 0; i < numRSBlocks; ++i)
            {
                int[] numDataBytesInBlock = new int[1];
                int[] numEcBytesInBlock   = new int[1];
                getNumDataBytesAndNumECBytesForBlockID(numTotalBytes, numDataBytes, numRSBlocks, i, numDataBytesInBlock, numEcBytesInBlock);

                ByteArray dataBytes = new ByteArray();
                dataBytes.set_Renamed(bits.Array, dataBytesOffset, numDataBytesInBlock[0]);
                ByteArray ecBytes = generateECBytes(dataBytes, numEcBytesInBlock[0]);
                blocks.Add(new BlockPair(dataBytes, ecBytes));

                maxNumDataBytes  = System.Math.Max(maxNumDataBytes, dataBytes.size());
                maxNumEcBytes    = System.Math.Max(maxNumEcBytes, ecBytes.size());
                dataBytesOffset += numDataBytesInBlock[0];
            }
            if (numDataBytes != dataBytesOffset)
            {
                throw new WriterException("Data bytes does not match offset");
            }

            // First, place data blocks.
            var bitLen = bits.size();

            for (int i = 0; i < maxNumDataBytes; ++i)
            {
                for (int j = 0; j < blocks.Count; ++j)
                {
                    ByteArray dataBytes = ((BlockPair)blocks[j]).DataBytes;
                    if (i < dataBytes.size())
                    {
                        if (bitLen == 4)
                        {
                            result.appendBits(dataBytes.at(i) >> 4, 4);
                        }
                        else
                        {
                            result.appendBits(dataBytes.at(i), 8);
                        }
                    }
                }
                bitLen -= 8;
            }

            // Then, place error correction blocks.
            for (int i = 0; i < maxNumEcBytes; ++i)
            {
                for (int j = 0; j < blocks.Count; ++j)
                {
                    ByteArray ecBytes = ((BlockPair)blocks[j]).ErrorCorrectionBytes;
                    if (i < ecBytes.size())
                    {
                        result.appendBits(ecBytes.at(i), 8);
                    }
                }
            }
            if (numTotalBytes != result.sizeInBytes())
            {
                // Should be same.
                throw new WriterException("Interleaving error: " + numTotalBytes + " and " + result.sizeInBytes() + " differ.");
            }
        }
 /// <summary> Append mode info. On success, store the result in "bits".</summary>
 internal static void appendModeInfo(Mode mode, BitVector bits, int versionNum)
 {
     bits.appendBits(mode.Bits, mode.getBitsLength(versionNum));
 }
        /// <summary> Terminate bits as described in 8.4.8 and 8.4.9 of JISX0510:2004 (p.24).</summary>
        internal static void terminateBits(int numDataBytes, BitVector bits, int versionNum)
        {
            int capacity = numDataBytes << 3;
            //ISO/IEC 18004:2006(E) 6.4.10 Bit stream to codeword conversion
            //All codewords are 8 bits in length, except for the final data symbol character in Micro
            //QR Code versions M1 and M3 symbols, which is 4 bits in length
            int bitLen = (versionNum == 1 || versionNum == 3) ? 4 : 8;

            if (bitLen == 4)
            {
                capacity -= 4;
            }

            if (bits.size() > capacity)
            {
                throw new WriterException("data bits cannot fit in the QR Code" + bits.size() + " > " + capacity);
            }
            // Append termination bits. See 8.4.8 of JISX0510:2004 (p.24) for details.
            // TODO: srowen says we can remove this for loop, since the 4 terminator bits are optional if
            // the last byte has less than 4 bits left. So it amounts to padding the last byte with zeroes
            // either way.
            var terminatorMode = Mode.TERMINATOR;
            var ctLen          = terminatorMode.getBitsLength(versionNum);

            for (int i = 0; i < ctLen && bits.size() < capacity; ++i)
            {
                bits.appendBit(0);
            }

            int numBitsInLastByte = bits.size() % bitLen;

            // If the last byte isn't 8-bit aligned, we'll add padding bits.
            if (numBitsInLastByte > 0)
            {
                int numPaddingBits = bitLen - numBitsInLastByte;
                for (int i = 0; i < numPaddingBits; ++i)
                {
                    bits.appendBit(0);
                }
            }

            // Should be 8-bit aligned here.
            if (bits.size() % bitLen != 0)
            {
                throw new WriterException("Number of bits is not a multiple of 8");
            }

            //ISO/IEC 18004:2006(E) 6.4.10 Bit stream to codeword conversion
            //The message bit stream shall then be
            //extended to fill the data capacity of the symbol corresponding to the Version and Error Correction Level, as
            //defined in Table 8, by adding the Pad Codewords 11101100 and 00010001 alternately.

            // If we have more space, we'll fill the space with padding patterns defined in 8.4.9 (p.24).
            int numPaddingBytes = numDataBytes - bits.sizeInBytes();

            while (numPaddingBytes * 8 > (capacity - bits.size()) && numPaddingBytes > 0)
            {
                numPaddingBytes--;
            }

            for (int i = 0; i < numPaddingBytes; ++i)
            {
                if (i % 2 == 0)
                {
                    bits.appendBits(0xec, 8); //11101100
                }
                else
                {
                    bits.appendBits(0x11, 8);//00010001
                }
            }
            //For Micro QR Code versions M1 and M3 symbols, the final data codeword is 4 bits long.  The Pad Codeword used in the final data
            //symbol character position in Micro QR Code versions M1 and M3 symbols shall be represented as 0000.
            if (bitLen == 4 && bits.size() < capacity)
            {
                bits.appendBits(0x0, 4);//0000
            }
            if (bits.size() != capacity)
            {
                throw new WriterException("Bits size does not equal capacity");
            }
        }