using System;
using System.Collections.Generic;
using System.Linq;
using TMPro;
using UnityEngine;
using Random = System.Random;

namespace WordGen {
    // TODO:
    // У героя есть 3 второстепенных персонажа, к которым он либо хорошо относится либо плохо. Для отношения нужна причина. В конце хорошие персонажи получают хорошее, а плохие плохое.
    // Часто герой в процессе приключений получает суперсилу. Так что суперсила это должно быть игровое понятие.
    // Как правило героя есть цель и антогонист, и его три приспешника. Герой по очареди побеждает преспешников (ну или тяжелые ситуации) а затем самого антогониста и выполняет цель.
    // Тут намешаны сразу две программы в одну Генератор относительно случайных (хотя возможно тематических) текстов. И генератор историй. Для второго всякие падежи и склонения не нужны вообще.
    // Делать генератор сюжетов вероятно легче всего поверх игровой модели-симуляции. Тоесть по сути эти зеро-бейсед игра-рогалик к которой подключен текстовый описатель, который умеет описывать игровые объекты словами. По сути в игре вывод на экран заменили выводом текста. Првда литературным вариантом.
    // Персонажи обладают знаниями
    // В сеттинге часто есть ПРАВИЛА МИРА:. Суперсила позволяет их нарушать.
    // Некотрые персонажей ГГ знает до начала истории, а с другими он как правило встречается по мере странствий, взаимодействует и в итоге формиурует отношение. Как правило они либо помогают игроку в беде, либо вредят в достижении дела.
    // местоимения
    // кроме местоимений также есть указание принадлежности: мой, его, её итд. Это крайне часто употребляется в повестовании. Конечно это надо делатъ не рандомно, а например каждому существу сделать инвентарь.
    // для разных сеттингов разные словари + базовый общий со словами вроде (идти, смотреть, дом, стул, стол итп.)
    // Если мы вводим в повестование какую-то новую сущность, то нужно её тогда немного описать, особенно в первый раз. И затем держать в голове. Тоесть все повестоватние нужно запоминать. Также старые сущности могут реагировать на новые.
    // Вставить словарь готовых слов либо как-то автоматизировать склонение и спряжение чтоб не вбивать вручную
    // как-то связать слова в группы по темам с которыми они связаны например если повестование идёт про море, то шансы появление слов связанных с морем повышаются.
    // Связать слова между собой, так как они чаще всего употребляются. Например шмыгать + носом или закатить глаза/истерику. Часто вариантов совсем не много.
    // Как-то ввести отношение героя/расказчика к предметам и другим персонажам. А так же довать оценку хорошо/плохо. Так же все действия тоже имеют градацию вредят они или опмогают кому-то: Тоесть ГГ будет вредить врагам и помагать друзьям.
    // простовой вид знаний это состовные части объектов. Например у розы есть шипы. У человека есть части тела, как и уживотных. У животных есть хвост. У бокала ножка. Бокал сделан из стекла. Итд итп. Хоть ПРОЛОГ подрубай.
    // Давать игроку выбор. Развилки сюжета.
    // С помощью ГУИ можно легко и быстро связть по группам слова и связать друг с дружкой глаголы, сущ. и прил. Это было бы крайне полезно в качестве хинтов для увеличения вероятности использования вместе.
    // special Verbs like say, talk, see, love, hate, live, deside etc should be available with no search by static ref
    // ensure names are uniq (use replacement names by collision or just generate the on fly from lattters) (or use nicknames from adj + noun)
    // Verb, Noun, Adj and Adverb must inheiret common abstract class Word
    // Очень часто удачно выпадает лишь часть истории. Нужна возможность перебросить кости на некотрых моментах или наоборот частично сохранять или устанавливать в ручную некотрые конкретные поля
    public class StoryTeller : MonoBehaviour {
        public TextMeshPro txt;
        public bool consoleOutput = false;

        const int adverb_chance = 5;

        public static Random rand = new Random();

        Story story;

        public void TellStory() {
            story = GetComponent<StoryMaker>().story;
            MakeDetails();
            txt.text = "";

            Chapter1();

            if (consoleOutput) {
                Debug.Log(txt.text);
            }
        }

        void Chapter1() {
            var vvv = WordsDB.verbs.Where(vv => vv.semantic_src == Semantic.CREATURE && string.IsNullOrEmpty(vv.casus)).ToList();
            vvv.Shuffle();
            Verb live = vvv.First();
            Verb damsel_verb = WordsDB.RandomVerb(Effect.GOOD);
            Adjective hero_adj = WordsDB.RandomAdjective();
            Adjective damsel_adj = WordsDB.RandomAdjective();
            Verb damsel_reacts = WordsDB.RandomVerb(Effect.GOOD);

            Log(Title(), true, false);
            Log("", true, false);
            Log("    ", false, false);
            Log(Intro(live));
            Log(DescByAdj(story.hero.name, hero_adj));
            Log(Related(story.damsel.name, story.hero.home));
            Log(FirstWordConfirmation() + IntroduceDamsel(damsel_adj));
            Log(AdoreDamsel(hero_adj, damsel_verb, damsel_adj));
            Log(Coin() ? TalkToDamsel1(damsel_adj) : TalkToDamsel2(damsel_adj));
            Log(DamselReacts(damsel_adj, damsel_reacts, hero_adj));

            Log("\n", true, false);

            Adjective antogonist_adj = WordsDB.RandomAdjective();
            Verb evil_to_damsel = WordsDB.RandomVerb(Effect.BAD);

            Log("    ", false, false);
            Log(AntogonistComes(live, antogonist_adj));
            string union = Coin() ? ", поэтому " : ", то ";
            Log(RandomReason(story.antogonist.name, antogonist_adj) + union + RandomAction(story.antogonist.name.uniqueName, evil_to_damsel, story.damsel.name));
            Log(PoorDamsel(damsel_adj, evil_to_damsel), false, false);
            Log(HeroReactsEvilDeed(damsel_adj, evil_to_damsel));
            Log(NeverHappenedInCity(antogonist_adj));

            Log("\n", true, false);

            Log(HeroFightsAntogonist());
            Log(AntogonistPunishment(antogonist_adj));
            Log(DamselRewardsHero(antogonist_adj));
            Log("\n\nКОНЕЦ", true, false);

            // Или еще короче:
            // тогда вответ на то плохое что сделал Злодей Любаве, ГГ сделал плохое Злодею.
            // И любава за это сделала хорошее Герою.
            // А злодей получил Наказание.
            // А любава и ГГ получили награду.

            //                ГГ думал что же делать.
            //                Но Злодей уже успел удрать из Родины на Чужбину.
            //                Кроме того злодей похитил Любаву.
            //                Любава нужна Злодею для альтернативного фактора.
            //                Это была угроза не только Любаве, но и Родине.
            //                ГГ осознал что любава теперь несчатна.
            //                Только сделав Подвиг с помощью Артефакт ГГ сможет снова сделать Любаву счастливой и спасти Родину.
            //                ГГ отправился на чужбину для этого и покинул Родину.
            //                Путь пролегал через Опасное_Место.
            //                В опасном Месте с ГГ случилось испытание.
            //                ГГ одолел испытание и смог отправится дальше.
            //                На подходе к Чужбине с ГГ случилось еще одно испытание.
            //                Еле одолев его ГГ получил Артефакт.
            //                Прибыв на чужбину наконец ГГ сразился с Злодей.
            //                ГГ почти проиграл так как злодей был очень силён.
            //                Но затем ГГ применил Артефакт и победил злодея.
            //                ГГ получил награду.
            //                Любава поблагорадила ГГ.
            //                Со злодеем в накзание случилось плохое.
            //                После наказания Злодея с Чужбиной случилось плохое.
            //                Вместе с Любавой они вернулись на Родину.
            //                Раньше на родине ГГ и Любава были обычные и не могли делать хорошее.
            //                А теперь на Родине ГГ и Любава стали важными и на родине им стало очень хорошо.
            //                КОНЕЦ.

        }


        void Log(object o, bool nl = false, bool point = true) {
            txt.text += CapitalizeFirst(o + (point ? "." : ""));
            txt.text += nl ? "\n" : " ";
        }

        public static bool Coin() {
            return rand.NextDouble() < 0.5;
        }

        static bool Chance(int chance) {
            return rand.NextDouble() * 100 < chance;
        }

        static string CapitalizeFirst(string str) {
            if (string.IsNullOrEmpty(str)) {
                return str;
            }

            string capital = str[0] + "";
            capital = capital.ToUpper();
            string end = "";
            if (str.Length > 1) {
                end = str.Substring(1);
            }

            return capital + end;
        }


        void MakeDetails() {
            story.hero.name = WordsDB.RandomHeroName(Coin() ? Genus.MALE : Genus.FEMALE);
            story.hero.job = WordsDB.nouns.Where(n => n.semantic == Semantic.CREATURE && n.genus == story.hero.name.genus).ToList().Rand();

            story.hero.home = WordsDB.RandomNoun(Semantic.LOCATION);
            story.hero.home.uniqueName = WordsDB.RandomNoun(Semantic.TOPONIM);


            story.damsel.name = WordsDB.RandomNoun(Semantic.CREATURE);
            story.damsel.name.uniqueName = WordsDB.RandomHeroName(story.damsel.name.genus);

            story.antogonist.name = WordsDB.RandomNoun(Semantic.CREATURE);
            story.antogonist.name.uniqueName = WordsDB.RandomHeroName(story.antogonist.name.genus);


        }

        string FirstWordConfirmation() {
            List<string> ss = new List<string>() { "всяко", "взаправду", "без сомнений", "определённо", "однозначно", "явно", "абсолютно", "правда",
                "в самом деле", "вне всякого сомнения", "в самом деле", "да-да", "ух как", "ах как", "ох как", "ах", "ох", "ух" };
            ss.Shuffle();
            return (Chance(33) ? "и " : "") + ss.First() + " ";
        }

        public string Title() {
            List<string> ss = new List<string>() { "История", "Сага", "Сказание", "Повесть", "Рассказ", "Очерк", "Баллада", "Былина", "Легенда",
                "Миф", "Сказ", "Небылица", "Опус", "Эссе", "Быль", "Летопись", "Писание", "Эпос", "Песнь", "Новелла", "Ода", "Трагедия", "Эпопея",
                "Ужас", "Поэма", "Эпиграмма", "Роман", "Гримдарк фентези", "Фентези", "Славянское фентези", "Шедевр", "Басня", "Былица", "Комедия",
                "Пьеса", "Откровение", "Пророчество", "Славяно-арийское фентези", "Славянское гримдарк фентези", "Славянское запрещённое фентези" };
            ss.Shuffle();

            string job = Coin() ? "" : story.hero.job.accusativ + " ";
            string title = ss.First() + " про " + job + story.hero.name.accusativ + " из " + story.hero.home.genetiv;
            title += " " + Quotes(story.hero.home.uniqueName.nominativ);


            title += ": " + CapitalizeFirst(story.hero.job.nominativ) + ", " + CapitalizeFirst(story.damsel.name.nominativ) + " и " + CapitalizeFirst(story.antogonist.name.nominativ);


            return title;
        }

        string Quotes(string str) {
            return "«" + str + "»";
        }



        string Intro(Verb live) {
            string sentence = "";
            var adverbs = WordsDB.adverbs.Where(a => a.type == Adverb.Type.TIME).ToList();
            adverbs.Shuffle();
            sentence += adverbs.First().txt;
            sentence += " в ";

            var adj = WordsDB.RandomAdjective();

            sentence += adj.Conj(story.hero.home.genus, Casus.L) + " ";

            sentence += story.hero.home.locativ;
            sentence += " " + Quotes(story.hero.home.uniqueName.nominativ);

            if (Chance(adverb_chance)) {
                sentence += " " + WordsDB.RandomAdverb();
            }


            sentence += " " + live.Past(story.hero.name.genus) + " ";
            sentence += story.hero.job.nominativ + " ";
            sentence += story.hero.name.nominativ;

            return sentence;
        }

        string Desc(Noun n) {
            return Coin() ? DescByAdj(n, WordsDB.RandomAdjective()) : DescByVerb(n);
        }

        string DescByVerb(Noun n) {
            string sentence = "";

            sentence += n.nominativ;

            Verb v = WordsDB.RandomVerb(n.semantic);
            sentence += " " + v.Past(n.genus);

            sentence += " " + AddNounToVerbIfPossible(v, WordsDB.RandomNoun());

            return sentence;
        }

        string DescByAdj(Noun n, Adjective adj) {
            string sentence = "";

            sentence += n.FullNameNominativ();

            Verb to_be = WordsDB.verbs.Find(v => v.infinitiv == "быть");

            sentence += " " + to_be.Past(n.genus) + " ";

            if (Coin()) {
                sentence += Coin() ?  "очень" : "чрезвычайно";
                sentence += " ";
            } else if (Chance(adverb_chance)) {
                sentence += WordsDB.RandomAdverb() + "-";
            }


            sentence += adj.Conj(n.genus, Casus.N);

            n.props.Add(adj);

            return sentence;
        }

        static string RandomAction(Noun n, Verb verb, Noun optional_skazuemoe) {
            return n.nominativ + " " + RandomAction(n.semantic, n.genus, verb, optional_skazuemoe);
        }

        static string RandomAction(Semantic who, Genus gender, Verb verb, Noun optional_skazuemoe) {
            string sentence = "";

            if (Chance(20)) {
                sentence += WordsDB.RandomAdverb().txt + " ";
            }

            sentence += verb.Past(gender);
            sentence += AddNounToVerbIfPossible(verb, optional_skazuemoe);

            return sentence;
        }

        static string AddNounToVerbIfPossible(Verb verb, Noun optional_skazuemoe) {
            string sentence = "";
            if (!string.IsNullOrEmpty(verb.casus)) {
                sentence += " ";
                if (!string.IsNullOrEmpty(verb.prefix)) {
                    sentence += verb.prefix;
                    sentence += " ";
                }

                sentence += verb.Sklonit(optional_skazuemoe);

                if (optional_skazuemoe.uniqueName != null) {
                    sentence += " " + verb.Sklonit(optional_skazuemoe.uniqueName);

                }


            }
            return sentence;
        }

        string RandomReason(Noun n, Adjective reason) {
            string sentence = "";

            List<string> w = new List<string>() { "так как", "по той причине, что", "из-за того, что", "в виду того, что", "в связи с тем, что", "в следствии того, что", "одновременно с тем, что" };
            w.Shuffle();

            sentence += w.First() + " " + DescByAdj(n, reason);


            return sentence;
        }

        string Judge(Noun who, Noun what, Verb v) {
            string sentence = "";

            string decide = "решил";

            if (who.genus == Genus.FEMALE) {
                decide += "а";
            }

            sentence += who.nominativ + " посмотрев как " + what.nominativ + " " + v.Past(what.genus) + " " + decide + " что " + what.nominativ + " " + WordsDB.RandomAdjective().Conj(what.genus, Casus.N);
            return sentence;
        }

        string LoveHate(bool pronoun, bool reason, Verb v, Noun optional_skazuemoe) {
            string sentence = "";
            sentence += !pronoun ? story.hero.name.nominativ : "она";
            bool positive = rand.NextDouble() < 0.5f;
            List<string> love = new List<string>() { "обожала", "очень любила", "любила", "предпочитала", "славилась тем что любила", "всё время любила" };
            List<string> hate = new List<string>() { "терпеть не могла", "ненавидела", "больше всего не любила", "очень не любила", "ох как не любила", "кровь из глаз не любила" };

            var arr = positive ? love : hate;
            arr.Shuffle();
            sentence += " " + arr.First() + " ";

            sentence += RandomAction(Semantic.CREATURE, story.hero.name.genus, v, optional_skazuemoe);

            if (reason) {
                if (!positive) {
                    var counter_reasons = new List<string>() {
                        "но к сожалению ничего не могла с собой поделать",
                        "но к своему глубочайшему сожалению не знала как этого избежать",
                        "но из-дня в день это повторялось",
                        "но к сожалению это прочно вошло в её жизнь",
                        "но по другому не получалось",
                        "но видимо такова уж была её судьба",
                    };
                    counter_reasons.Shuffle();
                    sentence += ", " + counter_reasons.First() + " ";
                } else {
                    var reasons = new List<string>() {
                        "она это просто обожала",
                        "это было её любимое занятие",
                        "это она любила больше всего",
                        "её нельзя было остановить когда она начинала"
                    };
                    reasons.Shuffle();
                    sentence += ", " + reasons.First();
                }
            }

            return sentence;
        }



        string IntroduceDamsel(Adjective adj) {
            string sentence = "";

            sentence += story.damsel.name.nominativ;

            if (Coin()) {
                sentence += " по имени";
            }

            sentence += " " + story.damsel.name.uniqueName.nominativ;

            Verb to_be = WordsDB.verbs.Find(v => v.infinitiv == "быть");
            sentence += " " + to_be.Past(story.damsel.name.genus) + " ";
            sentence += adj.Conj(story.damsel.name.genus, Casus.I) + " ";

            sentence += story.damsel.name.genus == Genus.MALE ? "обитателем" : "обитательницей";
            sentence += " " + story.hero.home.genetiv;

            return sentence;
        }

        string AdoreDamsel(Adjective hero_adj, Verb v, Adjective damsel_adj) {
            string sentence = "";


            List<string> ss = new List<string>() {
                "любил", "обожал", "превозносил", "боготворил", "любил"
            };

            string love = ss.Rand();
            if (story.hero.name.genus == Genus.FEMALE) {
                love += "а";
            }

            sentence += hero_adj.Conj(story.hero.name.genus, Casus.N) + " ";
            sentence += story.hero.name.nominativ + " так сильно " + love + " " + story.damsel.name.accusativ + " " + story.damsel.name.uniqueName.accusativ;
            sentence += ", что ";

            if (Chance(adverb_chance)) {
                sentence += WordsDB.RandomAdverb() + " ";
                if (Chance(adverb_chance)) {
                    sentence += "и " + WordsDB.RandomAdverb() + " ";
                }

            }

            string deed_to_show_love = v.Past(story.hero.name.genus);
            sentence += deed_to_show_love;
            sentence += AddNounToVerbIfPossible(v, story.damsel.name);

            sentence += ", ведь " + story.damsel.name.PronounNominativSingular3() + " настолько " + damsel_adj.Conj(story.damsel.name.genus, Casus.N);

            return sentence;

        }

        string My(Genus g) {
            switch (g) {
                case Genus.MALE:
                    return "мой";
                case Genus.FEMALE:
                    return "моя";
                case Genus.NEUTRAL:
                    return "моё";
                case Genus.PLURAL:
                    return "мои";
                default:
                    return "мой";
            }

        }

        string TalkToDamsel1(Adjective damsel_adj) {
            Noun damsel = story.damsel.name.uniqueName;

            string see = "видел";
            string talk = "говорил";

            if (story.hero.name.genus == Genus.FEMALE) {
                see += "а";
                talk += "а";
            }


            string sentence = "Когда " + story.hero.name.nominativ + " " + see + " " + damsel.accusativ + " то "
                              + story.hero.name.PronounNominativSingular3() + " всё время восхищённо " + talk + ": «";

            Genus gender = damsel.genus;
            sentence += CapitalizeFirst(My(gender)) + " " + WordsDB.RandomAdjective().Conj(gender, Casus.N) + " " + damsel.nominativ + ", ты просто ";

            if (Coin()) {
                sentence += "как ";
            }

            Noun compare = WordsDB.nouns.Where(x => x.semantic != Semantic.HERO).ToList().Rand();
            sentence += WordsDB.RandomAdjective().Conj(compare.genus, Casus.N) + " " + compare.nominativ + "! ";

            sentence += "Ах ты " + My(compare.genus) + " " + damsel_adj.Conj(compare.genus, Casus.N) + ", ";
            sentence += WordsDB.RandomAdjective().Conj(compare.genus, Casus.N) + " и ";
            sentence += WordsDB.RandomAdjective().Conj(compare.genus, Casus.N) + " ";
            sentence += compare.nominativ + "! ";
            sentence += "Ах! Я " + WordsDB.RandomVerb(Effect.GOOD).singular_1 + " и " + WordsDB.RandomVerb(Effect.GOOD).singular_1 + " когда я рядом с тобой!";


            sentence += "»";


            return sentence;
        }

        string TalkToDamsel2(Adjective damsel_adj) {
            Noun damsel = story.damsel.name.uniqueName;

            string see = "видел";
            string talk = "говорил";

            if (story.hero.name.genus == Genus.FEMALE) {
                see += "а";
                talk += "а";
            }


            string sentence = "Когда " + story.hero.name.nominativ + " " + see + " " + damsel.accusativ + " то "
                              + story.hero.name.PronounNominativSingular3() + " всё время восхищённо " + talk + ": «";

            Genus gender = damsel.genus;
            sentence += CapitalizeFirst(My(gender)) + " " + WordsDB.RandomAdjective().Conj(gender, Casus.N) + " " + damsel.nominativ + ", ты просто ";

            if (Coin()) {
                sentence += "как ";
            }

            Noun compare = WordsDB.nouns.Where(x => x.semantic != Semantic.HERO).ToList().Rand();
            sentence += WordsDB.RandomAdjective().Conj(compare.genus, Casus.N) + " " + compare.nominativ + "! ";

            sentence += "Ах ты " + My(compare.genus) + " " + damsel_adj.Conj(compare.genus, Casus.N) + " ";
            sentence += compare.nominativ + ", когда тебя нет рядом я ";
            sentence += WordsDB.RandomVerb(Effect.BAD).singular_1 + ", " + WordsDB.RandomVerb(Effect.BAD).singular_1 ;
            sentence += " и " + WordsDB.RandomVerb(Effect.BAD).singular_1 + "! Без " + compare.genetiv + " я просто " + WordsDB.RandomVerb(Effect.BAD).singular_1 + "!";

            sentence += "»";


            return sentence;
        }


        string DamselReacts(Adjective damsel_adj, Verb damsel_reaction, Adjective hero_adj) {
            string sentence = "Слыша это " + damsel_adj.Conj(story.damsel.name.genus, Casus.N) + " " + story.damsel.name.FullNameNominativ() + " ";
            sentence += Coin() ? "всегда" : "каждый раз";

            sentence += " " + WordsDB.adverbs.Where(x => x.type != Adverb.Type.TIME).ToList().Rand() + "-";
            sentence += WordsDB.adverbs.Where(x => x.type != Adverb.Type.TIME).ToList().Rand();

            sentence += " " + damsel_reaction.Past(story.damsel.name.genus);
            sentence += AddNounToVerbIfPossible(damsel_reaction, story.hero.name);
            sentence += ", ведь ";
            sentence += story.hero.name.genus == Genus.MALE ? "тот" : "та";
            sentence += " ";
            sentence += story.hero.name.genus == Genus.MALE ? "был" : "была";
            sentence += " ";
            sentence += hero_adj.Conj(story.hero.job.genus, Casus.I);
            sentence += " ";
            sentence += story.hero.job.instrumentalis;
            return sentence;
        }

        string PoorDamsel(Adjective damsel_adj, Verb evil_deed) {
            string sentence = "" + damsel_adj.Conj(story.damsel.name.genus, Casus.N) + " " + story.damsel.name.FullNameNominativ() + " ";

            sentence += story.damsel.name.genus == Genus.MALE ? "не мог" : "не могла";
            sentence += " поверить что " + story.antogonist.name.FullNameNominativ() + " ";
            sentence += Coin() ? "взаправду" : " на самом деле";
            sentence += " " + evil_deed.Past(story.antogonist.name.genus);
            if (!string.IsNullOrEmpty(evil_deed.prefix)) {
                sentence += " " + evil_deed.prefix + " " + story.damsel.name.Conj(evil_deed.casus);
            } else {
                // TODO: conj pronouns
                sentence += " " + (story.damsel.name.genus == Genus.MALE ? "его" : "её");
            }


            List<string> ss = new List<string>() {
                ". Но это было так!",
                ". Но это уже случилось!",
                ". Но это теперь свершившийся факт!",
                ". Но уже ничего не поменять!",
                ". Но что сделано то сделано!",
                ". Но это уже произошло!",
                ". Но ничего уже не изменить!",
                ". Но это произошло!",
                ". Но это факт!",
                ". Но вот так вот теперь!",
                ". Но что ж теперь делать!?",
                ". Но сделанного не обратить вспять!",
                ". Но деяние свершилось!",
                ". Но это уже случилося!",
                ". Но ох и ах, ух и э-хе-хе, теперь то поздно что-то выправлять!"
            };
            sentence += ss.Rand();

            return sentence;
        }

        string HeroReactsEvilDeed(Adjective damsel_adj, Verb evil_deed) {
            string sentence = "";

            List<string> ss = new List<string>() {
                "узнав что", "прослышав про то как", "прознав о том что", "получив информацию что", "увидев как", "услышав как", "пронюхав что"
            };

            sentence += ss.Rand() + " " + story.antogonist.name.FullNameNominativ() + " " + evil_deed.Past(story.antogonist.name.genus);

            sentence += AddNounToVerbIfPossible(evil_deed, story.damsel.name);
            sentence += ", " + story.hero.name.FullNameNominativ() + " ";
            sentence += story.hero.name.genus == Genus.MALE ? "был готов" : "была готова";
            Verb revenge_idea = WordsDB.verbs.Where(v => v.effect == Effect.BAD && !string.IsNullOrEmpty(v.casus)).ToList().Rand();
            sentence += " " + revenge_idea.infinitiv;
            sentence += AddNounToVerbIfPossible(revenge_idea, story.antogonist.name.uniqueName);
            sentence += " и " + WordsDB.RandomVerb(Effect.BAD).infinitiv;
            sentence += Coin() ? " от ярости" : " от гнева";

            return sentence;
        }

        string Related(Noun a, Noun b) {
            string sentence = "";
            List<string> ss = new List<string>() { "наверняка", "доподленно известно", "известно", "каждый знает", "как обычно", "постоянно", "взаимосвязанно", "два сапога пара", ""};
            ss.Shuffle();
            sentence += ss.First();
            if (!string.IsNullOrEmpty(sentence)) {
                sentence += " ";
            }

            ss = new List<string>() { "есть", "найдётся", "имеется", "в наличии", "находится", "будет", "в распоряжении"};
            ss.Shuffle();
            string frist = Coin() ? ss.First() + " " : "";

            ss = new List<string>() { "есть", "найдётся", "имеется", "в наличии", "находится", "обитает", "живёт", "будет", "в распоряжении" };
            ss.Shuffle();
            string second = ss.First();

            sentence += "где " + frist + b.nominativ + ", всегда " + second + " и " + a.nominativ;

            return sentence;
        }

        string AntogonistComes(Verb live, Adjective antogonist_adj) {
            string sentence = WordsDB.adverbs.Where(x => x.type == Adverb.Type.TIME).ToList().Rand().txt;
            sentence +=  " в " + story.hero.home.accusativ + " " + Quotes(story.hero.home.uniqueName.accusativ);

            sentence += ", где " + live.Past(story.hero.name.genus) + " " + story.hero.name.nominativ + ", ";

            Noun antogonist = story.antogonist.name;

            sentence += antogonist.genus == Genus.MALE ? "прибыл" : "прибыла";

            sentence += " " + antogonist_adj.Conj(antogonist.genus, Casus.N) + " " + antogonist.FullNameNominativ();





            return sentence;
        }


        string NeverHappenedInCity(Adjective antogonist_adj) {
            string sentence = "такое еще никогда не происходило в " + story.hero.home.locativ + " " + Quotes(story.hero.home.uniqueName.locativ) + ".";

            var gender = story.antogonist.name.genus;
            sentence += " Да, " + story.antogonist.name.FullNameNominativ() + " ";
            sentence += gender == Genus.MALE ? "был" : "была";
            sentence += Coin() ? " действительно" : " поистине";
            sentence += " " + antogonist_adj.Conj(gender, Casus.I);
            sentence += " и " + WordsDB.adjectives.Where(x => x.effect == Effect.BAD).ToList().Rand().Conj(gender, Casus.I);

            return sentence;
        }

        string HeroFightsAntogonist() {
            string sentence = story.hero.name.nominativ + " более не медля ";

            var gender = story.hero.name.genus;
            Verb revenge_of_hero = WordsDB.verbs.Where(v => !string.IsNullOrEmpty(v.casus) && v.effect == Effect.BAD).ToList().Rand();
            sentence += revenge_of_hero.Past(gender);
            sentence += " " + WordsDB.RandomNoun(Semantic.OBJECT).instrumentalis;
            sentence += AddNounToVerbIfPossible(revenge_of_hero, story.antogonist.name.uniqueName);
            sentence += " а затем и вовсе ";

            Verb fatality = WordsDB.verbs.Where(v => !string.IsNullOrEmpty(v.casus) && v.effect == Effect.BAD).ToList().Rand();
            sentence += fatality.Past(gender);
            sentence += " " + WordsDB.RandomNoun(Semantic.OBJECT).instrumentalis;
            sentence += AddNounToVerbIfPossible(fatality, story.antogonist.name);

            return sentence;
        }

        string AntogonistPunishment(Adjective adj) {
            string sentence = "так ";

            sentence += WordsDB.adverbs.Where(x => x.type != Adverb.Type.TIME).ToList().Rand() + "-";
            sentence += WordsDB.adverbs.Where(x => x.type != Adverb.Type.TIME).ToList().Rand() + " ";

            sentence += story.antogonist.name.FullNameNominativ() + " ";
            var gender = story.antogonist.name.genus;

            if (Coin()) {
                sentence += "и ";
                sentence += gender == Genus.MALE ? "умер" : "умерла";
            } else {
                sentence += "навсегда ";
                sentence += gender == Genus.MALE ? "покинул" : "покинула";
                sentence += " " + story.hero.home.accusativ + " " + Quotes(story.hero.home.uniqueName.accusativ);
            }



            return sentence;
        }

        string DamselRewardsHero(Adjective adj) {
            string sentence = "Ах ";
            var gender = story.damsel.name.genus;
            sentence += gender == Genus.MALE ? "каким " : "какой ";
            sentence += WordsDB.adjectives.Where(x => x.effect == Effect.GOOD).ToList().Rand().Conj(gender, Casus.I) + " и ";
            sentence += WordsDB.adjectives.Where(x => x.effect == Effect.GOOD).ToList().Rand().Conj(gender, Casus.I) + " ";
            sentence += gender == Genus.MALE ? "стал " : "стала ";
            sentence += adj.Conj(gender, Casus.N) + " ";
            sentence += story.damsel.name.FullNameNominativ() + " после этого. Тот час же ";
            sentence += gender == Genus.MALE ? "принялся " : "принялась ";
            sentence += story.damsel.name.PronounNominativSingular3() + " ";
            Verb reward_of_hero = WordsDB.verbs.Where(v => !string.IsNullOrEmpty(v.casus) && v.effect == Effect.GOOD).ToList().Rand();
            sentence += reward_of_hero.infinitiv;
            sentence += " и ";
            reward_of_hero = WordsDB.verbs.Where(v => !string.IsNullOrEmpty(v.casus) && v.effect == Effect.GOOD).ToList().Rand();
            sentence += reward_of_hero.infinitiv;
            sentence += AddNounToVerbIfPossible(reward_of_hero, story.hero.name);
            sentence += ", на что " + WordsDB.adverbs.Where(x => x.type != Adverb.Type.TIME).ToList().Rand() + " смотрели все в";
            sentence += " " + story.hero.home.locativ;





            return sentence;
        }







    }
}