Untitled

using System.Data;

namespace OtomataOdev
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        String emptyWord = "Ø";
        List<String> producededWords = new List<string>();
        Random random = new Random();

        private void btnProduce_Click(object sender, EventArgs e)
        {
            textBox1.Clear();
            resetAlhabetsText();
            String alphabet = textAlfabets.Text;
            String regularExpression = txtRegularExp.Text;
            int produceSizeOfWords = Convert.ToInt32(txtSizeOfWords.Text);
            printRegularExpression(regularExpression);
            printTheAlphabets(alphabet);
             produceWord(regularExpression, alphabet, produceSizeOfWords);
        }

        private void printTheAlphabets(String alphabet)
        {
            String[] alphabets = alphabet.Split(',');
            foreach (var item in alphabets)
            {
                txtAlphabetList.AppendText(item + " ");
            }
        }

        private void printRegularExpression(String regularExpression)
        {
            lblRegularExps.Text = regularExpression;
        }

        private void resetAlhabetsText()
        {
            txtAlphabetList.Clear();
        }

        private void produceWord(String regularExp, String alphabet, int produceSizeOfWords)
        {
            String normalWord = "";
            List<String> words = new List<String>();
            var validWord = "";
            var tempproduceSizeOfWords = produceSizeOfWords;
            while (tempproduceSizeOfWords >= 0)
            {
                validWord = "";
                normalWord = "";
                var i = 0;
                for (i = 0; i < regularExp.Length; i++)
                {
                    var item = regularExp[i];
                    if (item == '(')
                    {
                        if (!string.IsNullOrEmpty(normalWord))
                        {
                           validWord += normalWord;
                            produceSizeOfWords--;
                        }
                        int openParenthesisIndex = regularExp.IndexOf('(');
                        int closingParenthesisIndex = regularExp.IndexOf(')');
                        String subRule = regularExp.Substring(openParenthesisIndex + 1, (closingParenthesisIndex - 1) - openParenthesisIndex);
                        i = closingParenthesisIndex;
                        if (regularExp.Length > closingParenthesisIndex + 1 && regularExp[closingParenthesisIndex + 1] == '*')
                        {
                            words.Add(normalWord+"-");
                            words.Add(emptyWord + "-");
                            tempproduceSizeOfWords--; // Boş kelime ekledikten sonra 
                            // üretmemiz gereken kelime sayısını azaltıyorum.
                            for (int j = 0; j <= random.Next(10); j++)
                            {
                                if (subRule.Contains('+'))
                                {
                                    validWord += generateRandomWord(subRule);
                                }
                                else
                                {
                                    validWord += subRule;
                                }
                            }
                        }
                        else
                        {
                           
                            if(subRule.Contains('+') && subRule.Contains('*'))
                            {
                                var seperatedWords = subRule.Split('+');
                                var firstWord = seperatedWords.First();
                                var secondWord = seperatedWords.Last();
                               var randomNumber= random.Next(0,2);

                                if (randomNumber == 0)
                                {
                                    for (int j = 0; j < firstWord.Length; j++)
                                    {
                                        var wordItem = firstWord[j];
                                        if (wordItem == '*')
                                        {
                                            if (random.Next(0, 2) == 0)
                                            {
                                               continue;
                                            }
                                            else
                                            {
                                                // Eğer yıldızlı bir ifade ise o alfabeden istediğimiz
                                                // kadar ekleyebiliyorduk. Onu eklemiş oldum.
                                                var wordIndex = firstWord.IndexOf(wordItem, j);
                                                validWord = validWord.Remove(wordIndex-1);

                                                var word = firstWord[wordIndex - 1];
                                                for (int k = 0; k < random.Next(10); k++)
                                                {
                                                    validWord += word;
                                                }
                                            }
                                        }
                                        else
                                        {
                                            validWord += wordItem;
                                        }
                                    };
                                }
                                else
                                {
                                    for (int j = 0; j < secondWord.Length; j++)
                                    {
                                        var wordItem = secondWord[j];
                                        if (wordItem == '*')
                                        {
                                            if (random.Next(0, 2) == 0)
                                            {
                                                continue;
                                            }
                                            else
                                            {
                                                // Eğer yıldızlı bir ifade ise o alfabeden istediğimiz
                                                // kadar ekleyebiliyorduk. Onu eklemiş oldum.
                                                var wordIndex = secondWord.IndexOf(wordItem, j);
                                                validWord = validWord.Remove(wordIndex - 1);

                                                var word = secondWord[wordIndex - 1];
                                                for (int k = 0; k < random.Next(10); k++)
                                                {
                                                    validWord += word;
                                                }
                                            }
                                        }
                                        else
                                        {
                                            validWord += wordItem;
                                        }
                                    };
                                }                                                         
                            }
                           else if (subRule.Contains('+'))
                            {
                                validWord += generateRandomWord(subRule);
                            }
                            else
                            {
                                validWord += subRule;
                            }

                        }
                        words.Add(validWord + "-");
                    }
                    else if (item == '*')
                    {
                        // Eğer yıldızlı bir ifade ise o alfabeden istediğimiz
                        // kadar ekleyebiliyorduk. Onu eklemiş oldum.
                        var wordIndex = regularExp.IndexOf(item, i);
                        var word = regularExp[wordIndex - 1];
                        for (int j = 0; j < random.Next(10); j++)
                        {
                            validWord += word;
                        }
                    }
                    else if(item == '+')
                    {
                        normalWord += item;
                        var seperatedWord = generateRandomWord(normalWord);
                        words.Add(seperatedWord);
                    }
                    else
                    {
                        normalWord += item;
                    }
                }
                tempproduceSizeOfWords--;
            }

            foreach (var item in words.ToHashSet())
            {
                textBox1.AppendText(item);
            }
        }

        private String generateRandomWord(String subRule)
        {
            var validWord = "";
            var random = new Random().Next(0, 2);
            var seperatedWords = subRule.Split('+');

            if (random == 0)
            {
                return validWord += seperatedWords.First();
            }
            else
            {
                return validWord += seperatedWords.Last();
            }
        }

        private String generateRandomWord(String[] seperatedWords)
        {
            var validWord = "";
            var random = new Random().Next(0, 2);

            if (random == 0)
            {
                return validWord += seperatedWords.First();
            }
            else
            {
                return validWord += seperatedWords.Last();
            }
        }
        String aass = "";
        private void GenerateWord(String rule)
        {
            var item = rule[0];
            
                if (item=='(')
                {
                    if (!string.IsNullOrEmpty(aass))
                    {
                        producededWords.Add(aass);
                        rule = rule.Substring(aass.Length);
                    }
                    int openParenthesisIndex = rule.IndexOf('(');
                    int closingParenthesisIndex = rule.IndexOf(')');
                    String subRule = rule.Substring(openParenthesisIndex + 1, (closingParenthesisIndex - 1));
                    GenerateWord(subRule);
                }
                else if (item == '+')
                {
                    String[] seperatedWords = rule.Split("+");
                    var words =generateRandomWord(seperatedWords);
                    words.Trim('(');
                    words.Trim(')');
                    producededWords.Add(words);
                }
                else if(item == '*')
                {

                }
                else
                {
                    aass += item;
                }
           
        }

        private bool IsValidRegularExpression(string alphabet, string regularExpression)
        {
            foreach (var c in regularExpression)
            {
                if(c != '4' && c!='*' && c!='('&& c!= ')' && !alphabet.Contains(c))
                {
                    return false;
                }
            }
            return true;
        }
    }
}