using J2N.IO;
using J2N.Text;
using Lucene.Net.Benchmarks.ByTask.Tasks;
using Lucene.Net.Support;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using JCG = J2N.Collections.Generic;

namespace Lucene.Net.Benchmarks.ByTask.Utils
{
    /*
     * Licensed to the Apache Software Foundation (ASF) under one or more
     * contributor license agreements.  See the NOTICE file distributed with
     * this work for additional information regarding copyright ownership.
     * The ASF licenses this file to You under the Apache License, Version 2.0
     * (the "License"); you may not use this file except in compliance with
     * the License.  You may obtain a copy of the License at
     *
     *     http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */

    /// <summary>
    /// Test algorithm, as read from file
    /// </summary>
    public class Algorithm
    {
        private TaskSequence sequence;
        private readonly string[] taskPackages;

        /// <summary>
        /// Read algorithm from file.
        /// Property examined: alt.tasks.packages == comma separated list of 
        /// alternate Assembly names where tasks would be searched for, when not found 
        /// in the default Assembly (that of <see cref="PerfTask"/>).
        /// If the same task class appears in more than one Assembly, the Assembly
        /// indicated first in this list will be used.
        /// <para/>
        /// The Lucene.Net implementation differs from Lucene in that all
        /// referenced assemblies are also scanned for the type. However,
        /// alt.tasks.packages may be included for assemblies that are
        /// not referenced in your project.
        /// </summary>
        /// <param name="runData">perf-run-data used at running the tasks.</param>
        /// <exception cref="Exception">if errors while parsing the algorithm.</exception>
        public Algorithm(PerfRunData runData)
        {
            Config config = runData.Config;
            taskPackages = InitTasksPackages(config);
            string algTxt = config.AlgorithmText;
            sequence = new TaskSequence(runData, null, null, false);
            TaskSequence currSequence = sequence;
            PerfTask prevTask = null;
            StreamTokenizer stok = new StreamTokenizer(new StringReader(algTxt));
            stok.CommentChar('#');
            stok.EndOfLineIsSignificant = false;
            stok.QuoteChar('"');
            stok.QuoteChar('\'');
            stok.OrdinaryChar('/');
            stok.OrdinaryChar('(');
            stok.OrdinaryChar(')');
            bool colonOk = false;
            bool isDisableCountNextTask = false; // only for primitive tasks
            currSequence.Depth = 0;

            while (stok.NextToken() != StreamTokenizer.TokenType_EndOfStream)
            {
                switch (stok.TokenType)
                {

                    case StreamTokenizer.TokenType_Word:
                        string s = stok.StringValue;
                        PerfTask task = (PerfTask)Activator.CreateInstance(TaskClass(config, s), runData);
                        task.AlgLineNum = stok.LineNumber;
                        task.DisableCounting = isDisableCountNextTask;
                        isDisableCountNextTask = false;
                        currSequence.AddTask(task);
                        if (task is RepSumByPrefTask)
                        {
                            stok.NextToken();
                            string prefix = stok.StringValue;
                            if (prefix == null || prefix.Length == 0)
                            {
                                throw new Exception("named report prefix problem - " + stok.ToString());
                            }
                          ((RepSumByPrefTask)task).SetPrefix(prefix);
                        }
                        // check for task param: '(' someParam ')'
                        stok.NextToken();
                        if (stok.TokenType != '(')
                        {
                            stok.PushBack();
                        }
                        else
                        {
                            // get params, for tasks that supports them - allow recursive parenthetical expressions
                            stok.EndOfLineIsSignificant = true;  // Allow params tokenizer to keep track of line number
                            StringBuilder @params = new StringBuilder();
                            stok.NextToken();
                            if (stok.TokenType != ')')
                            {
                                int count = 1;
                                while (true)
                                {
                                    switch (stok.TokenType)
                                    {
                                        case StreamTokenizer.TokenType_Number:
                                            {
                                                @params.Append(stok.NumberValue.ToString(CultureInfo.InvariantCulture));
                                                break;
                                            }
                                        case StreamTokenizer.TokenType_Word:
                                            {
                                                @params.Append(stok.StringValue);
                                                break;
                                            }
                                        case StreamTokenizer.TokenType_EndOfStream:
                                            {
                                                throw new Exception("Unexpexted EOF: - " + stok.ToString());
                                            }
                                        case '"':
                                        case '\'':
                                            {
                                                @params.Append((char)stok.TokenType);
                                                // re-escape delimiters, if any
                                                @params.Append(stok.StringValue.Replace("" + (char)stok.TokenType, @"\" + (char)stok.TokenType));
                                                @params.Append((char)stok.TokenType);
                                                break;
                                            }
                                        case '(':
                                            {
                                                @params.Append((char)stok.TokenType);
                                                ++count;
                                                break;
                                            }
                                        case ')':
                                            {
                                                if (--count >= 1)
                                                {  // exclude final closing parenthesis
                                                    @params.Append((char)stok.TokenType);
                                                }
                                                else
                                                {
                                                    goto BALANCED_PARENS_BREAK;
                                                }
                                                break;
                                            }
                                        default:
                                            {
                                                @params.Append((char)stok.TokenType);
                                                break;
                                            }
                                    }
                                    stok.NextToken();
                                }
                                BALANCED_PARENS_BREAK: { }
                            }
                            stok.EndOfLineIsSignificant = false;
                            string prm = @params.ToString().Trim();
                            if (prm.Length > 0)
                            {
                                task.SetParams(prm);
                            }
                        }

                        // ---------------------------------------
                        colonOk = false; prevTask = task;
                        break;

                    default:
                        char c = (char)stok.TokenType;

                        switch (c)
                        {

                            case ':':
                                if (!colonOk) throw new Exception("colon unexpexted: - " + stok.ToString());
                                colonOk = false;
                                // get repetitions number
                                stok.NextToken();
                                if ((char)stok.TokenType == '*')
                                {
                                    ((TaskSequence)prevTask).SetRepetitions(TaskSequence.REPEAT_EXHAUST);
                                }
                                else
                                {
                                    if (stok.TokenType != StreamTokenizer.TokenType_Number)
                                    {
                                        throw new Exception("expected repetitions number or XXXs: - " + stok.ToString());
                                    }
                                    else
                                    {
                                        double num = stok.NumberValue;
                                        stok.NextToken();
                                        if (stok.TokenType == StreamTokenizer.TokenType_Word && stok.StringValue.Equals("s", StringComparison.Ordinal))
                                        {
                                            ((TaskSequence)prevTask).SetRunTime(num);
                                        }
                                        else
                                        {
                                            stok.PushBack();
                                            ((TaskSequence)prevTask).SetRepetitions((int)num);
                                        }
                                    }
                                }
                                // check for rate specification (ops/min)
                                stok.NextToken();
                                if (stok.TokenType != ':')
                                {
                                    stok.PushBack();
                                }
                                else
                                {
                                    // get rate number
                                    stok.NextToken();
                                    if (stok.TokenType != StreamTokenizer.TokenType_Number) throw new Exception("expected rate number: - " + stok.ToString());
                                    // check for unit - min or sec, sec is default
                                    stok.NextToken();
                                    if (stok.TokenType != '/')
                                    {
                                        stok.PushBack();
                                        ((TaskSequence)prevTask).SetRate((int)stok.NumberValue, false); // set rate per sec
                                    }
                                    else
                                    {
                                        stok.NextToken();
                                        if (stok.TokenType != StreamTokenizer.TokenType_Word) throw new Exception("expected rate unit: 'min' or 'sec' - " + stok.ToString());
                                        string unit = stok.StringValue.ToLowerInvariant();
                                        if ("min".Equals(unit, StringComparison.Ordinal))
                                        {
                                            ((TaskSequence)prevTask).SetRate((int)stok.NumberValue, true); // set rate per min
                                        }
                                        else if ("sec".Equals(unit, StringComparison.Ordinal))
                                        {
                                            ((TaskSequence)prevTask).SetRate((int)stok.NumberValue, false); // set rate per sec
                                        }
                                        else
                                        {
                                            throw new Exception("expected rate unit: 'min' or 'sec' - " + stok.ToString());
                                        }
                                    }
                                }
                                colonOk = false;
                                break;

                            case '{':
                            case '[':
                                // a sequence
                                // check for sequence name
                                string name = null;
                                stok.NextToken();
                                if (stok.TokenType != '"')
                                {
                                    stok.PushBack();
                                }
                                else
                                {
                                    name = stok.StringValue;
                                    if (stok.TokenType != '"' || name == null || name.Length == 0)
                                    {
                                        throw new Exception("sequence name problem - " + stok.ToString());
                                    }
                                }
                                // start the sequence
                                TaskSequence seq2 = new TaskSequence(runData, name, currSequence, c == '[');
                                currSequence.AddTask(seq2);
                                currSequence = seq2;
                                colonOk = false;
                                break;

                            case '&':
                                if (currSequence.IsParallel)
                                {
                                    throw new Exception("Can only create background tasks within a serial task");
                                }
                                stok.NextToken();
                                int deltaPri;
                                if (stok.TokenType != StreamTokenizer.TokenType_Number)
                                {
                                    stok.PushBack();
                                    deltaPri = 0;
                                }
                                else
                                {
                                    // priority
                                    deltaPri = (int)stok.NumberValue;
                                }

                                if (prevTask == null)
                                {
                                    throw new Exception("& was unexpected");
                                }
                                else if (prevTask.RunInBackground)
                                {
                                    throw new Exception("double & was unexpected");
                                }
                                else
                                {
                                    prevTask.SetRunInBackground(deltaPri);
                                }
                                break;

                            case '>':
                                currSequence.SetNoChildReport(); /* intentional fallthrough */
                                // end sequence
                                colonOk = true; prevTask = currSequence;
                                currSequence = currSequence.Parent;
                                break;
                            case '}':
                            case ']':
                                // end sequence
                                colonOk = true; prevTask = currSequence;
                                currSequence = currSequence.Parent;
                                break;

                            case '-':
                                isDisableCountNextTask = true;
                                break;

                        } //switch(c)
                        break;

                } //switch(stok.ttype)

            }

            if (sequence != currSequence)
            {
                throw new Exception("Unmatched sequences");
            }

            // remove redundant top level enclosing sequences
            while (sequence.IsCollapsable && sequence.Repetitions == 1 && sequence.GetRate() == 0)
            {
                IList<PerfTask> t = sequence.Tasks;
                if (t != null && t.Count == 1)
                {
                    PerfTask p = t[0];
                    if (p is TaskSequence)
                    {
                        sequence = (TaskSequence)p;
                        continue;
                    }
                }
                break;
            }
        }

        private string[] InitTasksPackages(Config config)
        {
            // LUCENENET specific - changing the logic a bit
            // to add all referenced assemblies by default.
            // The alt.tasks.packages parameter still exists, but
            // it is only necessary for assemblies that are not
            // referenced by the host assembly.

            ISet<string> result = new JCG.HashSet<string>();
            string alts = config.Get("alt.tasks.packages", null);
            string dfltPkg = typeof(PerfTask).Assembly.GetName().Name;
            IEnumerable<string> referencedAssemblies = AssemblyUtils.GetReferencedAssemblies().Select(a => a.GetName().Name);
            result.Add(dfltPkg);

            if (alts == null)
            {
                result.UnionWith(referencedAssemblies);
                return result.ToArray();
            }

            foreach (string alt in alts.Split(',').TrimEnd())
            {
                result.Add(alt);
            }
            result.UnionWith(referencedAssemblies);
            return result.ToArray();
        }

        private Type TaskClass(Config config, string taskName)
        {
            foreach (string pkg in taskPackages)
            {
                Type result = LoadType(pkg, taskName + "Task");
                if (result != null)
                {
                    return result;
                }
            }
            // can only get here if failed to instantiate
            throw new TypeLoadException(taskName + " not found in packages " + Collections.ToString(taskPackages));
        }

        private Type LoadType(string assemblyName, string typeName)
        {
            return Assembly.Load(new AssemblyName(assemblyName)).GetTypes().FirstOrDefault(t => t.Name == typeName);
        }

        public override string ToString()
        {
            string newline = Environment.NewLine;
            StringBuilder sb = new StringBuilder();
            sb.Append(sequence.ToString());
            sb.Append(newline);
            return sb.ToString();
        }

        /// <summary>
        /// Execute this algorithm.
        /// </summary>
        public virtual void Execute()
        {
            try
            {
                sequence.RunAndMaybeStats(true);
            }
            finally
            {
                sequence.Dispose();
            }
        }

        /// <summary>
        /// Expert: for test purposes, return all tasks participating in this algorithm.
        /// </summary>
        /// <returns>All tasks participating in this algorithm.</returns>
        public virtual IList<PerfTask> ExtractTasks()
        {
            List<PerfTask> res = new List<PerfTask>();
            ExtractTasks(res, sequence);
            return res;
        }

        private void ExtractTasks(IList<PerfTask> extrct, TaskSequence seq)
        {
            if (seq == null)
                return;
            extrct.Add(seq);
            IList<PerfTask> t = sequence.Tasks;
            if (t == null)
                return;
            foreach (PerfTask p in t)
            {
                if (p is TaskSequence)
                {
                    ExtractTasks(extrct, (TaskSequence)p);
                }
                else
                {
                    extrct.Add(p);
                }
            }
        }
    }
}
