using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

public class Program

{

    public static void Main()

    {

        //var results = new byte[] { 0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 0x04 };

        //var pattern = new byte[] { 0x04, 0x04, 0x04, 0x03 };

        var results = new List<byte> { 0x04, 0x03, 0x04, 0x03, 0x05, 0x04, 0x04, 0x04, 0x03, 0x05 };

        var pattern = new List<byte> { 0x04, 0x03, 0x04, 0x03, 0x05  };

        Console.WriteLine("---MatchRepeatPattern---\n");

        MatchRepeatPattern(results, pattern);

        /*

        Console.WriteLine("---GetUniquePattern---\n");

        var duplicatePattern = new List<byte> { 0x04, 0x04 };

        var uniquePattern = GetUniquePattern(duplicatePattern);

        Console.WriteLine("Pattern Result:");

        for (int i = 0; i < uniquePattern.Count(); i++)

        {

            Console.WriteLine(i + ") " + uniquePattern[i]);

        }*/

    }

    public static void MatchRepeatPattern(List<byte> results, List<byte> patterns)

    {

        bool isPatternIdentical = IsPatternIdentical(patterns);         //Check if pattern is identical

        if (!isPatternIdentical) patterns = GetUniquePattern(patterns); //Get Unique Pattern if pattern not identical

​

        int resultsLength = results.Count, patternLength = patterns.Count;

        int patternIndex = 0, resultsIndex = 0, result = -1;

        bool isFoundPattern = false;

​

        while (resultsIndex < resultsLength) {

            Console.WriteLine("Check Result(Index:" + resultsIndex +")-"+ results[resultsIndex] + ", Pattern(Index:" + patternIndex +")-" + patterns[patternIndex] + " = " + ((results[resultsIndex] & patterns[patternIndex]) == patterns[patternIndex]));

            if (resultsIndex >= patternLength * 2 && !isFoundPattern) break; // Quit if beyond possible match

​

            if (CompareResult(results[resultsIndex], patterns[patternIndex])) { // Result Matched

                if (isFoundPattern && isPatternIdentical) result++;     // Extend highlight when pattern is identical

​

                patternIndex++;

                resultsIndex++;

            } else if (resultsIndex < resultsLength && !CompareResult(results[resultsIndex], patterns[patternIndex])) { // Result Unmatched

                if (isFoundPattern) break;                              // Quit when pattern chain broken

​

                resultsIndex++;

                patternIndex = 0;

            }

​

            if (patternIndex == patternLength) {                        // Pattern Matched

                bool isFoundPatternPrefix = true;

                int startIndex = resultsIndex - patternLength;

                int endIndex = resultsIndex - 1;

                result = endIndex;

​

                Console.WriteLine("**Pattern matched from index " + startIndex + " to index " + endIndex);

                if (!isFoundPattern && startIndex > 0) {

                    for (int i = 0, j = patternLength - startIndex; i < startIndex; i++, j++) { 

                        if (!CompareResult(results[i], patterns[j])) {  // Make sure pattern prefix is matched

                            Console.WriteLine("**Pattern in progress mismatch");

                            isFoundPatternPrefix = false;

                            break;

                        }

                    }

                    if (!isFoundPatternPrefix) break;

                    isFoundPattern = isFoundPatternPrefix;

                } else {

                    isFoundPattern = true;

                }

​

                patternIndex = 0;

            }

        }

​

        if (isFoundPattern)

            Console.WriteLine("**Pattern found until index " + result);

        else 

            Console.WriteLine("**Pattern not found ");

    }

    public static bool CompareResult(int source, int target) {

        return (source & target) == target;

    }

    public static bool IsPatternIdentical(List<byte> patterns) {

        int sample = patterns[0];

​

        for (int i = 1; i < patterns.Count; i++) {

            if (sample != patterns[i]) return false;

        }

​

        return true;

    }

    public static List<byte> GetUniquePattern(List<byte> patterns)

    {

        List<byte> uniquePattern = new List<byte>();

        if (patterns.Count() == 0) return uniquePattern;

​

        //Pattern is not duplicate when different length

        uniquePattern.Add(patterns[0]);

        int uniquePatternIndex = 0;

        for (int i = 1; i < patterns.Count(); i++)

        {

            if (uniquePattern[uniquePatternIndex] != patterns[i])

            {

                while (uniquePattern.Count() - 1 < i)

                {

                    uniquePattern.Add(patterns[uniquePattern.Count]);

                }

                uniquePatternIndex = 0;

            }

            else

            {

                uniquePatternIndex++;

                if (uniquePatternIndex >= uniquePattern.Count) uniquePatternIndex = 0;

            }

        }

        if (uniquePatternIndex != 0) uniquePattern = patterns; //Pattern is not duplicate when different length

        return uniquePattern;

    }

    /*

    public static void ValidateRepeatPattern(byte[] results, byte[] pattern)

    {

        if (results.Length == 0 || pattern.Length == 0) return;

        int resultsLength = results.Length, patternLength = pattern.Length;

        int patternIndex = 0, resultsIndex = 0, result = -1;

        bool isFoundPattern = false, isPatternIdentical = IsPatternIdentical(pattern);

        while (resultsIndex < resultsLength)

        {

            Console.WriteLine("Check " + results[resultsIndex] + " - " + pattern[patternIndex] + " = " + ((results[resultsIndex] & pattern[patternIndex]) == pattern[patternIndex]));

            if (resultsIndex >= patternLength * 2 && !isFoundPattern) break; // Quit if beyond possible match

            if (CompareResult(results[resultsIndex], pattern[patternIndex])) // Result Matched

            {

                if (isFoundPattern && isPatternIdentical) result++; // Extend highlight when pattern is identical

                patternIndex++;

                resultsIndex++;

            }

            else if (resultsIndex < resultsLength && !CompareResult(results[resultsIndex], pattern[patternIndex])) // Result Unmatched

            {

                if (isFoundPattern) { Console.WriteLine("**Pattern Chain is Broken"); break; } // Quit when pattern chain broken

                resultsIndex++;

                patternIndex = 0;

            }

            if (patternIndex == patternLength)  // Pattern Matched

            {

                bool isFoundPatternPrefix = true;

                int startIndex = resultsIndex - patternLength;

                int endIndex = resultsIndex - 1;

                result = endIndex;

                Console.WriteLine("**Pattern matched from index " + startIndex + " to index " + endIndex);

                if (!isFoundPattern && startIndex > 0) {

                    for (int i=0, j=patternLength-startIndex; i < startIndex; i++, j++) { // Make sure pattern prefix is matched

                        if (!CompareResult(results[i], pattern[j])) {

                            Console.WriteLine("**Pattern in progress mismatch");

                            isFoundPatternPrefix = false;

                            break;

                        }

                    }

                    if (!isFoundPatternPrefix) break;

                    isFoundPattern = isFoundPatternPrefix;

                } else {

                    isFoundPattern = true;

                }

                patternIndex = 0;

            }

        }

        if (isFoundPattern)

            Console.WriteLine("**Pattern found until index " + result);

        else 

            Console.WriteLine("**Pattern not found ");

    }

    public static void ValidatePattern(byte[] results, byte[] pattern)

    {

        if (pattern.Length > results.Length) return;

        for (int i = 0; i < pattern.Length; i++)

        {

            if ((results[i] & pattern[i]) != pattern[i])

            {

                Console.WriteLine("**Pattern not found ");

                return;

            }

        }

        Console.WriteLine("**Pattern found until index " + (pattern.Length - 1));

    }

    */

}