//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="RegexInterpreter.IROptimize.cs"
// Project: StgSharp
// AuthorGroup: Nitload
// Copyright (c) Nitload. All rights reserved.
//     
// Permission is hereby granted, free of charge, to any person 
// obtaining a copy of this software and associated documentation 
// files (the “Software”), to deal in the Software without restriction, 
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software, 
// and to permit persons to whom the Software is furnished to do so, 
// subject to the following conditions:
//     
// The above copyright notice and 
// this permission notice shall be included in all copies 
// or substantial portions of the Software.
//     
// THE SOFTWARE IS PROVIDED “AS IS”, 
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
// ARISING FROM, OUT OF OR IN CONNECTION WITH 
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//     
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using StgSharp.Collections;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace StgSharp.RegularAnalysis.Text
{
    public partial class RegexAnalyzer
    {

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static RegexInfo ScanAndOptimizeIR(List<RegexIR> baseIR, out List<RegexIR> optIR)
        {
            int index = 0;
            Span<RegexIR> origin_span = CollectionsMarshal.AsSpan(baseIR);
            List<RegexIR> opt_ir = new(baseIR.Count);
            CapacityFixedList<RegexIR> opt_window = new(8);
            Span<RegexIR> opt_win_sp = [ .. opt_window ];
            RegexInfo info = new();
            do
            {
                int process_count = 0;
                int last = int.Min(origin_span.Length, index + 8);
                origin_span[index..last].CopyTo(opt_win_sp);

                do
                {
                    if (true) { }
                } while (false);

                index += process_count;
            } while (index < baseIR.Count);
            optIR = opt_ir;
            return info;
        }

        private void OptimizeRange(List<RegexIR> origin, List<RegexIR> target, int begin, int end) { }

        private static bool TryExpandComplexPlus(bool is_greedy, Span<RegexIR> complex, List<RegexIR> opt)
        {
            int count = complex.Length;
            opt.AddRange(complex);
            opt.Add(new RegexCountComplexIR(0, -1, is_greedy, count));
            return true;
        }

        #region expand plus

        private static int TryExpandPlus(Span<RegexIR> window, List<RegexIR> opt)
        {
            /* a+
             * convert to
             * aa*
             */

            RegexIR ir = window[0];
            if (ir is not IRegexCount { IsPlus: true } count) {
                return -1;
            }
            bool is_greedy = count.IsGreedy;
            string pattern;
            switch (ir.Command & RegexIRCommand.Count)
            {
                case RegexIRCommand.Count_Complex:
                    RegexCountComplexIR complex = Unsafe.As<RegexCountComplexIR>(ir);
                    return complex.OperationCount;
                case RegexIRCommand.Count_Seq:
                    RegexCountSeqIR seq = Unsafe.As<RegexCountSeqIR>(ir);
                    pattern = seq.Sequence;
                    opt.Add(new RegexMatchSeqIR(pattern));
                    opt.Add(new RegexCountSeqIR(0, -1, is_greedy, pattern));
                    return 0;
                case RegexIRCommand.Count_Set:
                    RegexCountSeqIR set = Unsafe.As<RegexCountSeqIR>(ir);
                    pattern = set.Sequence;
                    opt.Add(new RegexMatchSeqIR(pattern));
                    opt.Add(new RegexCountSeqIR(0, -1, is_greedy, pattern));
                    return 0;
                default:
                    return -1;
            }
        }

            #endregion

        private static bool TryFlattenCount(Span<RegexIR> window, List<RegexIR> opt)
        {
            RegexIR ir = window[0];
            if (ir is not RegexCountSeqIR seq) {
                return false;
            }
            return true;
        }

        #region dot count count

        private static int TryOptDotCountCount(Span<RegexIR> window, List<RegexIR> opt)
        {
            /* .* <any>*
             * convert to
             * .*
             */
            RegexIR cur_ir = window[0];
            if (cur_ir is not RegexCountSetIR { IsDotStar: true } dot) {
                return -1;
            }
            if (window[1] is not IRegexCount { IsStar: true } after) {
                return -1;
            }
            if (dot.IsGreedy)
            {
                opt.Add(window[0]);
                return 0;
            } else
            {
                /*
                 * .* ?a* is different
                 * it is something like
                 * FIND(a)?a* :.*
                 */
                RegexIRGenerator g = new();
                g.EmitTry(1);
            }
            return -1;
        }

            #endregion

        internal class RegexInfo
        {

            public int MinLength { get; set; }

            public int TryDepth { get; set; }

            public int GroupCount { get; set; }

        }

    }
}