using System;
using System.Drawing;
using System.Text;
using Vintasoft.Barcode;
using Vintasoft.Barcode.BarcodeInfo;
            
/// <summary>
/// Test that shows how to use Structured Append feature for distributing data message across
/// several 2D barcodes.
/// </summary>
class StructureAppendExample
{
            
    /// <summary>
    /// Runs the test.
    /// </summary>
    public static void Test()
    {
        BarcodeType barcodeType = BarcodeType.DataMatrix;
            
        int symbolsCount = 5;
            
        string symbolsValue =
            "In order to fit a non-square area or to handle larger messages than are practical " +
            "in a single symbol, a data message can be distributed across several symbols. " +
            "Aztec, Code 16K, DataMatrix, MaxiCode, QR Code, PDF417, Micro PDF417 "+
            "symbols may be appended in a structured format.";
            
        // split data and generate barcodes
        Image[] barcodeImages = GenerateBarcodes(barcodeType, symbolsValue, symbolsCount);
            
        // resort barcode images
        Array.Reverse(barcodeImages);
        Array.Reverse(barcodeImages, 0, barcodeImages.Length / 2);
            
        // read barcodes and merge data value
        string readValue = ReadBarcodeValue(barcodeImages, barcodeType);
            
        if (readValue == symbolsValue)
            Console.WriteLine("Success");
        else
            throw new ApplicationException();
    }
            
    /// <summary>
    /// Splits value and generates symbolCount barcodes using Structured Append.
    /// </summary>
    public static Image[] GenerateBarcodes(BarcodeType barcodeType, string value, int symbolCount)
    {
        // create an image array
        Image[] result = new Image[symbolCount];
            
        // create the barcode writer
        BarcodeWriter writer = new BarcodeWriter();        
        
        // specify that writer must generate barcode of specified type
        writer.Settings.Barcode = barcodeType;
            
        // create parity data for a QR barcode value
        byte parityData = 0;
        if (barcodeType == BarcodeType.QR)
            parityData = QRStructuredAppendCharacter.CaluculateParityData(value);
            
        // generate symbols(barcodes)
        int fragmentLength = value.Length / symbolCount;
        for (int i = 0; i < symbolCount; i++)
        {
            // create Structured Append character
            
            StructuredAppendCharacter structureAppendCharacter;
            switch (barcodeType)
            {
                case BarcodeType.Aztec:
                    structureAppendCharacter =
                        new AztecStructuredAppendCharacter(i + 1, symbolCount, "");
                    break;
            
                case BarcodeType.DataMatrix:
                    structureAppendCharacter =
                        new DataMatrixStructuredAppendCharacter(i + 1, symbolCount, 0);
                    break;
            
                case BarcodeType.QR:
                    structureAppendCharacter =
                        new QRStructuredAppendCharacter(i + 1, symbolCount, parityData);
                    break;
                
                case BarcodeType.Code16K:
                    structureAppendCharacter =
                        new StructuredAppendCharacter(i + 1, symbolCount);
                    writer.Settings.Height = 200;
                    break;
            
                case BarcodeType.MaxiCode:
                    structureAppendCharacter =
                        new StructuredAppendCharacter(i + 1, symbolCount);
                    break;
            
                case BarcodeType.MicroPDF417:
                    structureAppendCharacter =
                        new PDF417StructuredAppendCharacter(i + 1, symbolCount, "123");
                    break;
            
                case BarcodeType.PDF417:
                    structureAppendCharacter =
                        new PDF417StructuredAppendCharacter(i + 1, symbolCount, "123");
                    break;
            
                default:
                    throw new NotSupportedException();
            }
            
            // create symbol data
            
            string symbolTextData;
            if (i == symbolCount - 1)
                symbolTextData = value.Substring(i * fragmentLength);
            else
                symbolTextData = value.Substring(i * fragmentLength, fragmentLength);
            
            TextValueItem symbolData = new TextValueItem(symbolTextData);
            
            // set the barcode value items
            writer.Settings.ValueItems = new ValueItemBase[] { structureAppendCharacter, symbolData };
            
            // create image with barcode
            result[i] = writer.GetBarcodeAsBitmap();
        }
            
        return result;
    }
            
    /// <summary>
    /// Reads barcodes and merges the results into a single value.
    /// </summary>
    private static string ReadBarcodeValue(Image[] barcodeImages, BarcodeType barcodeType)
    {
        // create the barcode reader
        using (BarcodeReader reader = new BarcodeReader())
        {
            // specify that reader must search for barcodes of specified type
            reader.Settings.ScanBarcodeTypes = barcodeType;
            
            // barcode reading results
            IBarcodeInfo[] readingResults = new IBarcodeInfo[barcodeImages.Length];
            // read barcodes
            for (int i = 0; i < barcodeImages.Length; i++)
            {
                // read barcode from image
                readingResults[i] = reader.ReadBarcodes(barcodeImages[i])[0];
            
                // dispose image
                barcodeImages[i].Dispose();
            }
            
            // determine symbol count
            int symbolsCount = 0;
            for (int i = 0; i < readingResults.Length; i++)
            {
                if (readingResults[i].ValueItems[0] is StructuredAppendCharacter)
                {
                    symbolsCount = ((StructuredAppendCharacter)readingResults[i].ValueItems[0]).SymbolCount;
                    break;
                }
            }
            if (symbolsCount == 0)
                throw new ApplicationException("No Structured Append symbols.");
            
            // create array of string
            string[] resultValues = new string[symbolsCount];
            // fill resultValues
            for (int i = 0; i < readingResults.Length; i++)
            {
                if (readingResults[i].ValueItems[0] is StructuredAppendCharacter)
                {
                    StructuredAppendCharacter structureAppendCharacter =
                        (StructuredAppendCharacter)readingResults[i].ValueItems[0];
                    if (structureAppendCharacter.SymbolCount == symbolsCount)
                    {
                        readingResults[i].ShowNonDataFlagsInValue = false;
                        resultValues[structureAppendCharacter.SymbolPosition - 1] = readingResults[i].Value;
                    }
                }
            }
            
            // build result string
            StringBuilder result = new StringBuilder();
            for (int i = 0; i < resultValues.Length; i++)
            {
                if (resultValues[i] != null)
                {
                    result.Append(resultValues[i]);
                }
                else
                {
                    throw new ApplicationException(string.Format("missing symbol at position {0}", i + 1));
                }
            }
            
            return result.ToString();
        }
    }
            
}