using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace C_LightParser.Models
{
    public class AnalyzerModel : BaseModel
    {
        public static List<RuleModel> AllRules = new List<RuleModel>();

        public static string[,] Table;

        public static int RowsCount = 0;
        public static int ColumnsCount = 0;

        public static List<string> ToList(string str)
        {
            var result = new List<string>();
            for (var i = 0; i < str.Length; i++)
            {
                if (str[i] == '<')
                {
                    for (int j = i; j < str.Length; j++)
                    {
                        if (str[j] == '>')
                        {
                            result.Add(str.Substring(i, j - i + 1));
                            i = j;
                            break;
                        }
                    }
                }

                if (str[i] == '\'')
                {
                    for (int j = i + 1; j < str.Length; j++)
                    {
                        if (str[j] == '\'')
                        {
                            result.Add(str.Substring(i, j - i + 1));
                            i = j;
                            break;
                        }
                    }
                }
            }
            return result;
        }

        public static void GenerateTable()
        {
            var excelService = new ExcelService();
            var terminals = new List<string>();
            var nonTerminals = new List<string>();
            foreach (var rule in AllRules)
            {
                nonTerminals.Add(rule.NonTerminal);
                foreach (var list in rule.RuleSet)
                {
                    foreach (var sets in list)
                    {
                        for (int i = 0; i < sets.Length; i++)
                        {
                            bool seekingTerminal = true;
                            foreach (var terminal in terminals)
                            {
                                if (terminal == sets[i])
                                {
                                    seekingTerminal = false;
                                    break;
                                }

                            }
                            if (seekingTerminal)
                            {
                                if ((sets[i][0] == '\'') && (sets[i][sets[i].Length - 1] == '\'')) terminals.Add(sets[i]);
                            }
                        }
                    }
                }
            }
            terminals.Add("$");
            Table = new string[nonTerminals.Count + 1, terminals.Count + 1];

            for (var i = 0; i < nonTerminals.Count + 1; i++)
            {
                for (var j = 0; j < terminals.Count + 1; j++)
                {
                    Table[i, j] = "NULL";
                }
            }

            for (var i = 1; i < nonTerminals.Count + 1; i++)
            {
                Table[i, 0] = nonTerminals[i - 1];
            }

            for (var i = 1; i < terminals.Count + 1; i++)
            {
                Table[0, i] = terminals[i - 1];
            }


            RowsCount = terminals.Count + 1;
            ColumnsCount = nonTerminals.Count + 1;

            var finalList = new List<string>();
            var resultList = new List<string>();
            var ruleList = new List<string[]>();

            int row = 1;

            foreach (var rule in AllRules)
            {
                foreach (var ruleSet in rule.RuleSet)
                {
                    foreach (var sets in ruleSet)
                    {
                        var input = String.Empty;
                        var f = false;
                        foreach (var set in sets)
                        {
                            input += set;
                        }

                        First(sets, new List<string>(), resultList);

                        foreach (var resultSet in resultList)
                        {
                            if (resultSet == "\' \'")
                            {
                                f = true;
                            }
                        }

                        foreach (var resultSet in resultList)
                        {
                            for (var i = 1; i < terminals.Count + 1; i++)
                            {
                                if (resultSet == Table[0, i])
                                {
                                    //if (s == "\' \'") Table[k, Terminal.Count] = input;
                                    Table[row, i] = input;
                                }
                            }
                        }

                        if (f)
                        {
                            Follow(rule, finalList);
                            foreach (var resultSet in resultList)
                            {
                                foreach (var finalSet in finalList)
                                {
                                    if (resultSet == finalSet)
                                    {
                                        finalList.Remove(finalSet);
                                    }
                                }
                            }

                            foreach (var finalSet in finalList)
                            {
                                for (var i = 1; i < terminals.Count + 1; i++)
                                {
                                    if (finalSet == Table[0, i])
                                    {
                                        //if (s == "\' \'") Table[k, Terminal.Count] = input;
                                        Table[row, i] = "\' \'";
                                    }
                                }
                            }
                        }

                        resultList = new List<string>();
                        finalList = new List<string>();
                    }
                }
                row++;
            }

            row = 1;
            foreach (var ruleSet in AllRules)
            {
                Follow(ruleSet, resultList);
                foreach (var resultSet in resultList)
                {
                    for (var i = 1; i < terminals.Count + 1; i++)
                    {
                        if (resultSet == Table[0, i])
                        {
                            if (Table[row, i] == "NULL")
                            {
                                Table[row, i] = "synch";
                            }
                        }
                    }
                }
                resultList = new List<string>();
                row++;
            }

            row = 1;
            foreach (var ruleSet in AllRules)
            {
                First(ruleSet, new List<string>(), resultList);
                foreach (var resultSet in resultList)
                {
                    for (int i = 1; i < terminals.Count + 1; i++)
                    {
                        if (resultSet == Table[0, i])
                        {
                            if (Table[row, i] == "NULL")
                            {
                                Table[row, i] = "synch";
                            }
                        }
                    }
                }
                resultList = new List<string>();
                row++;
            }
            //EA.Recording(Table, NotTerminal.Count + 1, Terminal.Count + 1);
        }

        public static void First(string[] inputRule, List<string> inputList, List<string> ResultList)
        {
            var resultList = inputList;
            var finalResultList = ResultList;
            var result = string.Empty;
            var notEqualsWithInput = true;
            var equalsWithInput = false;
            for (var i = 0; i < inputRule.Length; i++)
            {
                if (inputRule[i] == "\' \'")
                {
                    foreach (var resultRule in resultList)
                    {
                        if (resultRule == inputRule[i])
                        {
                            notEqualsWithInput = false;
                            equalsWithInput = true;
                            break;
                        }
                    }
                    if (notEqualsWithInput)
                    {
                        resultList.Add(inputRule[i]);
                        equalsWithInput = true;
                    }
                    break;
                }
                if ((inputRule[i][0] == '\'') && (inputRule[i][inputRule[i].Length - 1] == '\''))
                {
                    foreach (var resultRule in resultList)
                    {
                        if (resultRule == inputRule[i])
                        {
                            notEqualsWithInput = false;
                            equalsWithInput = true;
                            break;
                        }
                    }
                    if (notEqualsWithInput)
                    {
                        resultList.Add(inputRule[i]);
                        equalsWithInput = true;
                    }
                    break;
                }
                if ((inputRule[i][0] == '<') && (inputRule[i][inputRule[i].Length - 1] == '>'))
                {
                    foreach (var rule in AllRules)
                    {
                        if (inputRule[i] == rule.NonTerminal)
                        {
                            First(rule, resultList, finalResultList);
                            equalsWithInput = true;
                            break;
                        }
                    }
                }
                if (equalsWithInput)
                {
                    equalsWithInput = false;
                    break;
                }
            }
            foreach (var resultSet in resultList)
            {
                bool setsNotEquals = true;
                foreach (string finalResultSet in finalResultList)
                {
                    if (finalResultSet == resultSet)
                    {
                        setsNotEquals = false;
                    }
                }
                if (setsNotEquals)
                {
                    finalResultList.Add(resultSet);
                }
            }

        }

        public static void First(RuleModel inputRule, List<string> inputList, List<string> ResultList)
        {
            var resultList = inputList;
            var finalResultList = ResultList;
            var result = string.Empty;
            var notFromResultList = true;
            var fromResultList = false;
            var exitFlag = false;
            foreach (var ruleList in inputRule.RuleSet)
            {

                foreach (var rule in ruleList)
                {
                    for (var i = 0; i < rule.Length; i++)
                    {
                        exitFlag = true;
                        if (rule[i] == "\' \'")
                        {
                            foreach (var resultSet in resultList)
                            {
                                if (resultSet == rule[i])
                                {
                                    notFromResultList = false;
                                    fromResultList = true;
                                    exitFlag = false;
                                    break;
                                }
                            }
                            if (notFromResultList)
                            {
                                resultList.Add(rule[i]);
                                fromResultList = true;
                            }
                            break;
                        }
                        if ((rule[i][0] == '\'') && (rule[i][rule[i].Length - 1] == '\''))
                        {
                            foreach (var resultSet in resultList)
                            {
                                if (resultSet == rule[i])
                                {
                                    notFromResultList = false;
                                    fromResultList = true;
                                    break;
                                }
                            }
                            if (notFromResultList)
                            {
                                resultList.Add(rule[i]);
                                fromResultList = true;
                            }
                            break;
                        }
                        if ((rule[i][0] == '<') && (rule[i][rule[i].Length - 1] == '>'))
                        {
                            foreach (var ruleSet in AllRules)
                            {
                                if (rule[i] == ruleSet.NonTerminal)
                                {
                                    First(ruleSet, resultList, finalResultList);
                                    fromResultList = true;
                                    break;
                                }
                            }
                        }
                        if (fromResultList)
                        {
                            fromResultList = false;
                            break;
                        }
                    }
                }
                foreach (var resultSet in resultList)
                {
                    if (resultSet == "\' \'")
                    {
                        exitFlag = false;
                    }
                }
                foreach (var resultSet in resultList)
                {
                    bool setsNotEquals = true;
                    foreach (var finalResultSet in finalResultList)
                    {
                        if (finalResultSet == resultSet)
                        {
                            setsNotEquals = false;
                        }
                    }
                    if (setsNotEquals)
                    {
                        finalResultList.Add(resultSet);
                    }
                }
                if (exitFlag)
                {
                    break;
                }
            }
        }

        public static void Follow(RuleModel inputRule, List<string> inputList)
        {
            //bool glFlag = true;
            var flag = true;
            var resultList = inputList;
            var result = string.Empty;
            foreach (var ruleSets in AllRules)
            {
                if (ruleSets.NonTerminal == inputRule.NonTerminal)
                {
                    continue;
                }
                foreach (var ruleSet in ruleSets.RuleSet)
                {
                    foreach (var set in ruleSet)
                    {
                        flag = true;
                        //glFlag = true;
                        for (var i = 0; i < set.Length; i++)
                        {
                            if (set[i] == "\' \'")
                            {
                                continue;
                                /*Follow(r, resultList);
                                glFlag = false;
                                break;*/
                            }
                            if (set[i] == inputRule.NonTerminal)
                            {
                                if (i + 1 == set.Length)
                                {
                                    Follow(ruleSets, resultList);
                                    for (int i1 = 0; i1 < resultList.Count; i1++) if (resultList[i1] == "\' \'") resultList.Remove(resultList[i1]);
                                    break;
                                }
                                if (i + 1 != set.Length)
                                {
                                    for (int k = i + 1; k < set.Length; k++)
                                    {
                                        bool isEmptySymbol = true;
                                        foreach (var anotherRule in AllRules)
                                        {
                                            if (anotherRule.NonTerminal == set[k])
                                            {
                                                var finalList = new List<string>();
                                                finalList = resultList;
                                                First(anotherRule, resultList, finalList);
                                                resultList = finalList;
                                                foreach (var resultSet in resultList)
                                                {
                                                    if (resultSet == "\' \'")
                                                    {
                                                        isEmptySymbol = false;
                                                    }
                                                }
                                                foreach (var resultSet in resultList)
                                                {
                                                    if (resultSet == "\' \'")
                                                    {
                                                        Follow(anotherRule, resultList);
                                                        for (var j = 0; j < resultList.Count; j++) if (resultList[j] == "\' \'") resultList.Remove(resultList[j]);
                                                        break;
                                                    }
                                                }
                                                flag = false;
                                                break;
                                            }
                                        }

                                        if (flag)
                                        {
                                            var resultNotEqual = true;
                                            foreach (var resultSet in resultList)
                                            {
                                                if (resultSet == set[i + 1])
                                                {
                                                    resultNotEqual = false;
                                                }
                                            }
                                            if (resultNotEqual)
                                            {
                                                resultList.Add(set[i + 1]);
                                            }

                                            if (set[i + 1] == "\' \'")
                                            {
                                                isEmptySymbol = true;
                                            }
                                        }

                                        if (isEmptySymbol)
                                        {
                                            break;
                                        }
                                    }
                                    //glFlag = false;
                                    break;
                                }
                            }

                        }
                        //if (glFlag) break;
                    }

                }
            }

        }

        public static void Analyze(List<string> input, List<string> magazine)
        {
            var flagCont = true;
            var symbolNumber = 1;
            var column = 0;
            var row = 0;
            var errorCount = 0;
            var deep = 0;


            while (input.Count > 0)
            {
                if ((magazine[0] == "\'$\'") && (input[0] == "\'$\'"))
                {
                    break;
                }

                if (magazine[0] == "\'$\'")
                {
                    errorCount++;
                    Console.WriteLine("Error: MagStack is Empty: " + input[0] + " ( Номер символа: " + symbolNumber + ")");
                    break;
                }
                if (input[0] == "\'$\'")
                {
                    errorCount++;
                    Console.WriteLine("Error: InputStack is Empty: " + magazine[0] + " ( Номер символа: " + symbolNumber + ")");
                    break;
                }

                if (magazine[0][0] == '<')
                {
                    column = 0;
                    row = 0;
                    flagCont = true;
                    for (int i = 1; i < AnalyzerModel.RowsCount; i++)
                    {
                        if (input[0] == AnalyzerModel.Table[0, i])
                        {
                            column = i;
                            break;
                        }
                    }

                    if (column == 0)
                    {
                        errorCount++;
                        Console.WriteLine("Error:" + input[0] + " ( Номер символа: " + symbolNumber + ")");
                        input.Remove(input[0]);
                        flagCont = false;
                    }

                    if (flagCont)
                    {
                        for (int i = 1; i < AnalyzerModel.ColumnsCount; i++)
                        {
                            if (AnalyzerModel.Table[i, 0] == magazine[0])
                            {
                                row = i;
                                break;
                            }
                        }

                        if ((magazine[0] == "<empty>") && (input[0] != "' '"))
                        {
                            magazine.Remove(magazine[0]);
                            continue;
                        }

                        if (AnalyzerModel.Table[row, column] == "NULL")
                        {
                            errorCount++;
                            Console.WriteLine("Error:" + input[0] + " ( Номер символа: " + symbolNumber + "; Ожидался:" + magazine[0] + ")");
                            input.Remove(input[0]);
                            //magStack.Remove(magStack[0]);
                            symbolNumber++;
                            continue;
                        }

                        if (AnalyzerModel.Table[row, column] == "synch")
                        {
                            errorCount++;
                            Console.WriteLine("Error:" + input[0] + " ( Номер символа: " + symbolNumber + "; Ожидался:" + magazine[0] + ")");
                            magazine.Remove(magazine[0]);
                            //inputStack.Remove(inputStack[0]);
                            symbolNumber++;
                            continue;
                        }



                        List<string> RuleList = AnalyzerModel.ToList(AnalyzerModel.Table[row, column]);
                        magazine.Remove(magazine[0]);
                        List<string> TimeList = magazine;
                        magazine = new List<string>();
                        foreach (var ruleSet in RuleList)
                        {
                            magazine.Add(ruleSet);
                        }
                        foreach (var ruleSet in TimeList)
                        {
                            magazine.Add(ruleSet);
                        }
                        continue;
                    }

                }

                if (magazine[0][0] == '\'')
                {
                    if (magazine[0] == input[0])
                    {
                        magazine.Remove(magazine[0]);
                        input.Remove(input[0]);
                        symbolNumber++;
                        continue;
                    }

                    errorCount++;
                    Console.WriteLine("Error:" + input[0] + " ( Номер символа: " + symbolNumber + "; Ожидался:" + magazine[0] + ")");
                    input.Remove(input[0]);
                    symbolNumber++;
                    continue;
                }

                if (deep > 50) break;
                deep++;
            }
            Console.WriteLine("Errors = " + errorCount);
        }
    }
}