using System;
using System.Collections.Generic;
using GroupDocs.Signature;
using GroupDocs.Signature.Domain;
using GroupDocs.Signature.Options;

string filePath = "sample_multiple_signatures.docx";
using (Signature signature = new Signature(filePath))
{
    // बहु-हस्ताक्षर खोज कोड यहां जोड़ा जाएगा
}

// पाठ हस्ताक्षरों के लिए खोज विकल्प परिभाषित करें
TextSearchOptions textOptions = new TextSearchOptions
{
    AllPages = true,  // सभी पृष्ठों पर खोजें
    Text = "Signature",  // वैकल्पिक: खोजने के लिए पाठ
    MatchType = TextMatchType.Contains  // मिलान मानदंड
};

// डिजिटल हस्ताक्षरों के लिए खोज विकल्प परिभाषित करें
DigitalSearchOptions digitalOptions = new DigitalSearchOptions
{
    AllPages = true
};

// बारकोड हस्ताक्षरों के लिए खोज विकल्प परिभाषित करें
BarcodeSearchOptions barcodeOptions = new BarcodeSearchOptions
{
    AllPages = true,
    Text = "123456",  // वैकल्पिक: मिलान करने के लिए बारकोड पाठ
    MatchType = TextMatchType.Exact  // मिलान मानदंड
};

// QR कोड हस्ताक्षरों के लिए खोज विकल्प परिभाषित करें
QrCodeSearchOptions qrCodeOptions = new QrCodeSearchOptions
{
    AllPages = true,
    Text = "John",  // वैकल्पिक: मिलान करने के लिए QR कोड टेक्स्ट
    MatchType = TextMatchType.Contains  // मिलान मानदंड
};

// मेटाडेटा हस्ताक्षरों के लिए खोज विकल्प परिभाषित करें
MetadataSearchOptions metadataOptions = new MetadataSearchOptions();

// सभी खोज विकल्पों को रखने के लिए एक सूची बनाएँ
List<SearchOptions> searchOptions = new List<SearchOptions>
{
    textOptions,
    digitalOptions,
    barcodeOptions,
    qrCodeOptions,
    metadataOptions
};

// निर्धारित विकल्पों का उपयोग करके सभी हस्ताक्षर प्रकारों की खोज करें
SearchResult result = signature.Search(searchOptions);

// जाँच करें कि हस्ताक्षर मिले या नहीं
if (result.Signatures.Count > 0)
{
    Console.WriteLine($"\nSource document ['{filePath}'] contains {result.Signatures.Count} signature(s):");
    
    // पाए गए हस्ताक्षरों के माध्यम से पुनरावृति करें
    foreach (var foundSignature in result.Signatures)
    {
        Console.WriteLine($"Signature found: Type: {foundSignature.SignatureType}, Page: {foundSignature.PageNumber}, ID: {foundSignature.SignatureId}");
        
        // प्रक्रिया विशिष्ट हस्ताक्षर प्रकार
        if (foundSignature is TextSignature textSignature)
        {
            Console.WriteLine($"Text: '{textSignature.Text}'");
        }
        else if (foundSignature is BarcodeSignature barcodeSignature)
        {
            Console.WriteLine($"Barcode Type: {barcodeSignature.EncodeType.TypeName}, Text: '{barcodeSignature.Text}'");
        }
        else if (foundSignature is QrCodeSignature qrCodeSignature)
        {
            Console.WriteLine($"QR Code Type: {qrCodeSignature.EncodeType.TypeName}, Text: '{qrCodeSignature.Text}'");
        }
        else if (foundSignature is DigitalSignature digitalSignature)
        {
            Console.WriteLine($"Certificate: {digitalSignature.Certificate?.SubjectName}, Valid: {digitalSignature.IsValid}");
        }
        else if (foundSignature is MetadataSignature metadataSignature)
        {
            Console.WriteLine($"Metadata: Name: {metadataSignature.Name}, Value: {metadataSignature.Value}");
        }
    }
}
else
{
    Console.WriteLine("No signatures were found in the document.");
}

using System;
using System.Collections.Generic;
using GroupDocs.Signature;
using GroupDocs.Signature.Domain;
using GroupDocs.Signature.Options;

namespace MultiSignatureSearch
{
    class Program
    {
        static void Main(string[] args)
        {
            // दस्तावेज़ पथ
            string filePath = "sample_multiple_signatures.docx";
            
            // हस्ताक्षर उदाहरण आरंभ करें
            using (Signature signature = new Signature(filePath))
            {
                try
                {
                    // पाठ हस्ताक्षरों के लिए खोज विकल्प परिभाषित करें
                    TextSearchOptions textOptions = new TextSearchOptions
                    {
                        AllPages = true,
                        MatchType = TextMatchType.Contains
                    };

                    // डिजिटल हस्ताक्षरों के लिए खोज विकल्प परिभाषित करें
                    DigitalSearchOptions digitalOptions = new DigitalSearchOptions
                    {
                        AllPages = true
                    };

                    // बारकोड हस्ताक्षरों के लिए खोज विकल्प परिभाषित करें
                    BarcodeSearchOptions barcodeOptions = new BarcodeSearchOptions
                    {
                        AllPages = true
                    };

                    // QR कोड हस्ताक्षरों के लिए खोज विकल्प परिभाषित करें
                    QrCodeSearchOptions qrCodeOptions = new QrCodeSearchOptions
                    {
                        AllPages = true
                    };

                    // मेटाडेटा हस्ताक्षरों के लिए खोज विकल्प परिभाषित करें
                    MetadataSearchOptions metadataOptions = new MetadataSearchOptions();

                    // सभी खोज विकल्पों को रखने के लिए एक सूची बनाएँ
                    List<SearchOptions> searchOptions = new List<SearchOptions>
                    {
                        textOptions,
                        digitalOptions,
                        barcodeOptions,
                        qrCodeOptions,
                        metadataOptions
                    };

                    // सभी प्रकार के हस्ताक्षर खोजें
                    SearchResult result = signature.Search(searchOptions);

                    // जाँच करें कि हस्ताक्षर मिले या नहीं
                    if (result.Signatures.Count > 0)
                    {
                        Console.WriteLine($"\nSource document ['{filePath}'] contains {result.Signatures.Count} signature(s):");
                        
                        // हस्ताक्षर प्रकार के अनुसार प्रक्रिया परिणाम
                        foreach (var foundSignature in result.Signatures)
                        {
                            Console.WriteLine($"Signature found: Type: {foundSignature.SignatureType}, Page: {foundSignature.PageNumber}");
                            
                            // प्रक्रिया विशिष्ट हस्ताक्षर प्रकार
                            switch (foundSignature.SignatureType)
                            {
                                case SignatureType.Text:
                                    var textSignature = foundSignature as TextSignature;
                                    Console.WriteLine($"Text: '{textSignature.Text}'");
                                    break;
                                    
                                case SignatureType.Barcode:
                                    var barcodeSignature = foundSignature as BarcodeSignature;
                                    Console.WriteLine($"Barcode Type: {barcodeSignature.EncodeType.TypeName}, Text: '{barcodeSignature.Text}'");
                                    break;
                                    
                                case SignatureType.QrCode:
                                    var qrCodeSignature = foundSignature as QrCodeSignature;
                                    Console.WriteLine($"QR Code Type: {qrCodeSignature.EncodeType.TypeName}, Text: '{qrCodeSignature.Text}'");
                                    break;
                                    
                                case SignatureType.Digital:
                                    var digitalSignature = foundSignature as DigitalSignature;
                                    Console.WriteLine($"Certificate: {digitalSignature.Certificate?.SubjectName}, Valid: {digitalSignature.IsValid}");
                                    break;
                                    
                                case SignatureType.Metadata:
                                    var metadataSignature = foundSignature as MetadataSignature;
                                    Console.WriteLine($"Metadata: Name: {metadataSignature.Name}, Value: {metadataSignature.Value}");
                                    break;
                            }
                            
                            Console.WriteLine(); // हस्ताक्षरों के बीच लाइन ब्रेक जोड़ें
                        }
                    }
                    else
                    {
                        Console.WriteLine("No signatures were found in the document.");
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error occurred: {ex.Message}");
                }
            }
            
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}

// पृष्ठ संख्या के अनुसार परिणाम फ़िल्टर करें
var signaturesOnFirstPage = result.Signatures.FindAll(s => s.PageNumber == 1);

// हस्ताक्षर प्रकार के अनुसार परिणाम फ़िल्टर करें
var digitalSignatures = result.Signatures.FindAll(s => s.SignatureType == SignatureType.Digital);
var qrCodeSignatures = result.Signatures.FindAll(s => s.SignatureType == SignatureType.QrCode);

// विशिष्ट सामग्री वाले टेक्स्ट हस्ताक्षरों को फ़िल्टर करें
var approvalSignatures = result.Signatures
    .FindAll(s => s is TextSignature && ((TextSignature)s).Text.Contains("Approved"));

bool ValidateAllSignatures(SearchResult result)
{
    bool isDocumentValid = true;
    
    // जाँच करें कि दस्तावेज़ में वैध डिजिटल हस्ताक्षर है या नहीं
    bool hasValidDigitalSignature = result.Signatures
        .Any(s => s is DigitalSignature && ((DigitalSignature)s).IsValid);
    
    if (!hasValidDigitalSignature)
    {
        Console.WriteLine("Warning: Document does not contain a valid digital signature");
        isDocumentValid = false;
    }
    
    // जांचें कि दस्तावेज़ में आवश्यक QR कोड है या नहीं
    bool hasRequiredQRCode = result.Signatures
        .Any(s => s is QrCodeSignature && ((QrCodeSignature)s).Text.Contains("Auth-Code"));
    
    if (!hasRequiredQRCode)
    {
        Console.WriteLine("Warning: Document does not contain the required authentication QR code");
        isDocumentValid = false;
    }
    
    return isDocumentValid;
}

// कस्टम प्रोसेसिंग के साथ खोज विकल्प बनाएँ
TextSearchOptions textOptions = new TextSearchOptions
{
    AllPages = true,
    
    // प्रतिनिधि का उपयोग करके कस्टम प्रसंस्करण परिभाषित करें
    ProcessCompleted = (signature) =>
    {
        // कस्टम सत्यापन तर्क - केवल निर्दिष्ट पृष्ठों पर हस्ताक्षर स्वीकार करें
        TextSignature textSignature = signature as TextSignature;
        return textSignature != null && (textSignature.PageNumber == 1 || textSignature.PageNumber == 2);
    }
};

LoadOptions loadOptions = new LoadOptions { Password = "your_password" };
using (Signature signature = new Signature(filePath, loadOptions))
{
    // हस्ताक्षर खोजें
}

TextSearchOptions options = new TextSearchOptions
{
    AllPages = false,  // सभी पृष्ठों को न खोजें
    PageNumber = 1,    // केवल पृष्ठ 1 पर खोजें
    
    // या एकाधिक पृष्ठ निर्दिष्ट करें
    PagesSetup = new PagesSetup { Pages = new List<int> { 1, 3, 5 } }
};