using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

//https://stackoverflow.com/questions/75338574/indexof-char-within-an-readonlyspanbyte-of-utf8-bytes

​

#nullable enable

​

    public static class StringExtensions

    {

        const int MaxBytes = 4;

​

        public static int IndexOf(this ReadOnlySpan<byte> utf8Bytes, char @char)

        {

            Rune rune;

            try

            {

                rune = new Rune(@char);

            }

            catch (ArgumentOutOfRangeException)

            {

                // Malformed unicode character, return -1 or throw?

                return -1;

            }

            return utf8Bytes.IndexOf(rune);

        }       

        public static int IndexOf(this ReadOnlySpan<byte> utf8Bytes, Rune @char)

        {

            Span<byte> charBytes = stackalloc byte[MaxBytes];

            var n = @char.EncodeToUtf8(charBytes);

            charBytes = charBytes.Slice(0, n);

            for (int i = 0, thisLength = 1; i <= utf8Bytes.Length - charBytes.Length; i += thisLength)

            {

                thisLength = Utf8ByteSequenceLength(utf8Bytes[i]);

                if (thisLength == charBytes.Length && charBytes.CommonPrefixLength(utf8Bytes.Slice(i)) == charBytes.Length)

                    return i;

            }

            return -1;

        }       

        internal static int Utf8ByteSequenceLength(byte firstByte)

        {

            //https://en.wikipedia.org/wiki/UTF-8#Encoding

            if (     (firstByte & 0b11111000) == 0b11110000) // 11110xxx

                return 4;

            else if ((firstByte & 0b11110000) == 0b11100000) // 1110xxxx

                return 3;

            else if ((firstByte & 0b11100000) == 0b11000000) // 110xxxxx

                return 2;

            return 1; // Either a 1-byte sequence (matching 0xxxxxxx) or an invalid start byte.

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            Test("𩸽?hello", 'z');

            Test("𩸽?hello", '\a');

            Test("", 'o');

            Test("o", 'o');

            Test("o", '\0');

            Test("α𝛂𝛼𝜶𝝰𝞪𩸽?hello", 'o');

            Test("α𝛂𝛼𝜶𝝰𝞪𩸽?hello", '\xFF');

            Test("α𝛂𝛼𝜶𝝰𝞪𩸽?hello", '\xfe');

            Test("α𝛂𝛼𝜶𝝰𝞪𩸽?hello", '\x01');

            Test("α𝛂𝛼𝜶𝝰𝞪𩸽?hello", '\xFFFF');

            Test("α𝛂𝛼𝜶𝝰𝞪𩸽?hello", '\xDC00');

            Test("α𝛂𝛼𝜶𝝰𝞪𩸽?hello", 'α');

            Test("α𝛂𝛼𝜶𝝰𝞪𩸽?hello", new Rune("𝞪"[0], "𝞪"[1]));

            Test("?hello\U00029E3D", new Rune("\U00029E3D"[0], "\U00029E3D"[1]));

            Test("?hello\U00029E3D", default(Rune));

        }   

        public static void Test(string s, char c)

        {

            AssertCharacterByteSequenceLengthCorrect(s);

​

            ReadOnlySpan<byte> bytes = Encoding.UTF8.GetBytes(s);

​

            var index = bytes.IndexOf(c);

            var charIndex = s.IndexOf(c, StringComparison.OrdinalIgnoreCase);

            var charFound = charIndex >= 0;

            var found = index >= 0;

            Console.WriteLine($"For s={s} and c={c}, index={index}, charIndex={charIndex}");

            Assert.That(charFound == found, $"For s={s} and c={c}, {charFound} != {found}");

            var charBytes = Encoding.UTF8.GetBytes(c.ToString());

​

            if (charBytes.Length == 1 && bytes.Length == s.Length) // All 1-byte ASCII

                Assert.AreEqual(charIndex, index, $"{charIndex} == {index}");

        }   

        public static void Test(string s, Rune c)

        {

            AssertCharacterByteSequenceLengthCorrect(s);

            ReadOnlySpan<byte> bytes = Encoding.UTF8.GetBytes(s);

​

            var index = bytes.IndexOf(c);

            var charIndex = s.IndexOf(c.ToString(), StringComparison.OrdinalIgnoreCase);

            var charFound = charIndex >= 0;

            var found = index >= 0;

            Console.WriteLine($"For s={s} and c={c}, index={index}, charIndex={charIndex}");

            Assert.That(charFound == found, $"For s={s} and c={c}, {charFound} != {found}");

            var charBytes = Encoding.UTF8.GetBytes(c.ToString());

​

            if (charBytes.Length == 1 && bytes.Length == s.Length) // All 1-byte ASCII

                Assert.AreEqual(charIndex, index, $"{charIndex} == {index}");

        }   

        static void AssertCharacterByteSequenceLengthCorrect(string s)

        {

            Span<byte> charBytes = stackalloc byte[6];

            for (int i = 0; i < s.Length;)

            {

                if (!Rune.TryGetRuneAt(s, i, out Rune rune))

                {

                    throw new Exception("String was not well-formed UTF-16.");

                }

​

                var n = rune.EncodeToUtf8(charBytes);

                Assert.That(n == StringExtensions.Utf8ByteSequenceLength(charBytes[0]));

                i += rune.Utf16SequenceLength; // increment the iterator by the number of chars in this Rune

            }           

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1}), {2}", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription, Environment.Version, Environment.OSVersion);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​

// Source links:

// https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/String.Searching.cs#L47

// https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Text/UTF8Encoding.cs#L758

// https://stackoverflow.com/questions/1301402/example-invalid-utf8-string

// https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt

// https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Text/Rune.cs#L1056

​

// As an alternative, Rune.DecodeFromUtf8() can be used to chew through a ReadOnlySpan<Byte> Rune by Rune.

// https://learn.microsoft.com/en-us/dotnet/api/system.text.rune.decodefromutf8?view=net-7.0#system-text-rune-decodefromutf8(system-readonlyspan((system-byte))-system-text-rune@-system-int32@)

​