// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
#nullable disable
 
using System;
using System.Diagnostics;
using Microsoft.CodeAnalysis.Text;
 
namespace Microsoft.CodeAnalysis.NamingStyles
{
    internal partial record struct NamingStyle
    {
        private struct WordSpanEnumerator
        {
            private readonly string _name;
            private readonly TextSpan _nameSpan;
            private readonly string _wordSeparator;
 
            public WordSpanEnumerator(string name, TextSpan nameSpan, string wordSeparator)
            {
                Debug.Assert(nameSpan.Length > 0);
                _name = name;
                _nameSpan = nameSpan;
                _wordSeparator = wordSeparator;
                Current = new TextSpan(nameSpan.Start, 0);
            }
 
            public TextSpan Current { get; private set; }
 
            public bool MoveNext()
            {
                if (_wordSeparator == "")
                {
                    // No separator.  So only ever return a single word
                    if (Current.Length == 0)
                    {
                        Current = _nameSpan;
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
 
                while (true)
                {
                    var nextWordSeparator = _name.IndexOf(_wordSeparator, Current.End);
                    if (nextWordSeparator == Current.End)
                    {
                        // We're right at the word separator.  Skip it and continue searching.
                        Current = new TextSpan(Current.End + _wordSeparator.Length, 0);
                        continue;
                    }
 
                    // If didn't find a word separator, it's as if the next word separator is at the end of name span.
                    if (nextWordSeparator < 0)
                    {
                        nextWordSeparator = _nameSpan.End;
                    }
 
                    // If we've walked past the _nameSpan just immediately stop.  There are no more words to return.
                    if (Current.End > _nameSpan.End)
                    {
                        return false;
                    }
 
                    // found a separator in front of us.  Note: it may be in our suffix portion.  
                    // So use the min of the separator position and our end position.
                    Current = TextSpan.FromBounds(Current.End, Math.Min(_nameSpan.End, nextWordSeparator));
                    break;
                }
 
                return Current.Length > 0 && Current.End <= _nameSpan.End;
            }
        }
    }
}