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


/*/
 * Parašyti metodą, kuris duotoje eilutėje surastų nurodytą žodį ir jį perkeltų
   į eilutės pabaigą. Jei eilutėja yra keli vienodi ieškomi žodžiai, keliamas tik
   pirmas iš jų. Skyrikliai nekeliami. Žodžio neradus - perkelėmis neatliakamas.

 * Atlikti veiksmus žinant, kad A = a
/*/

namespace _2
{
    class Program
    {
        static void Main(string[] args)
        {

            string skyrikliai = " ,.";

            string[] tekstas = System.IO.File.ReadAllLines("...//...//Tekstas.txt", Encoding.GetEncoding(1257));

            for (int i = 0; i < tekstas.Length; i++)
                RastiŽodį(ref tekstas[i], skyrikliai, "Gal");

            System.IO.File.WriteAllLines("...//...//Rezultatai.txt", tekstas);

        }
        /*----------------------------------------------------------------------------------*/
        static void RastiŽodį(ref string eilutė, string skyrikliai, string duotasŽodis)
        {
            int pr = 0;
            string[] zodziai = eilutė.Split(skyrikliai.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

            for (int i = 0; i < zodziai.Length; i++)
                if (zodziai[i].ToLower() == duotasŽodis.ToLower())
                {
                    int poz = 0;        //kintamasis, parodantis per kiek pozicijų redaguojama eilutė nukirpta.
                    string e = eilutė;  //susikuriama nauja eilutė, kurią pus galima redaguoti ir karpyti.
                    while (true)
                    {
                        bool skyriklisPriekyje = false, skyriklisGale = false;  //loginiai kintamiesi pasakantys ar skyriklis yra tam tikrose vietose.
                        char a = e[0], b = e[0];    //char elementai, kurių realiai net nereikią, bet taip paprasčiau atrodo... jie saugo simbolius prieš ir po žodžio, pradžioje prilyginami pirmajai raidei, nes kitaip meta errorą kad nėra prilyginti.

                        pr = e.IndexOf(zodziai[i]); //redaguojamoje eilutėje randą pirmą duotam žodžiui atitinkančią simbolių seką. (toliau "seka")

                        if (pr > 0)     //tikrina ar ta seka nėra eilutės pradžioje.
                            a = e[pr - 1];      //jeigu nėra, tada simbolį prieš tą seką įdedame į char kintamajį a.
                        else
                            skyriklisPriekyje = true;       //jeigu seka yra pradžioje, tada prieš ją nėra jokių simbolių, o tai galime skaityti kaip skyriklį, tad skyriklisPrikyje = true;

                       if (pr + zodziai[i].Length < e.Length)   //panašiai kaip ir prieš tai buves metodas, tik šis tikrina ar sekos pirmo simbolio vieta + duoto žodžio ilgis yra mažesnis už visos eilutės ilgį. yra tik 2 galimi variantai, arba mažesnis, arba lygus, didesnis nebus, nes tai jau eina iš eilutės, kurioje yra tas žodis... tiesiog nelogiška.
                           b = e[pr + zodziai[i].Length]; //jeigu mažesnis, tada prie sekos pradžios pridedame duotoodžio ilgį, ir gauname simbolio vietą esančią už sekos, tai tariamasis skyriklis.
                       else
                           skyriklisGale = true;    //jeigu ne, seka yra pačiame eilutės gale, kas ,kaip ir su pradžia, prilyginama skyrikliui, tad skyriklisGale = true;

                       if (!skyriklisPriekyje)  //jeigu atlikus tikrinimus prieš tai, žodis nebuvo eilutės priekyje, atliekame toliau einančius veiksmus.
                           skyriklisPriekyje = skyrikliai.Contains(a);  //tikriname ar simbolis prieš seką yra skyriklis.

                       if (!skyriklisGale)  //jeigu atlikus tikrinimus prieš tai, žodis nebuvo eilutės gale, atliekame toliau einančius veiksmus.
                           skyriklisGale = skyrikliai.Contains(b);  //tikriname ar simbolis už sekos yra skyriklis.

                        if (skyriklisPriekyje && skyriklisGale) //jeigu atlikus visus prieš tai sekusius veiksmus gauname, kad prieš seka ir už sekos yra skyrikliai, arba tariami skyrikliai (pradžia, galas), atliekame veiksmus su pagrindine eilute.
                        {
                            eilutė = eilutė.Remove(poz + pr, zodziai[i].Length);    //iš pagrindinės eilutės pašaliname duotą žodį. poz + pr, parodo vietą, kurioje yra žodis (nukirptų simbolių kiekis redaguojamoje eilutėje + sekos pradžios vieta redaguojamoje eilutėje)
                            eilutė = eilutė + zodziai[i];   // prie eilutės galo pridedame duotą žodį.
                            break; //stabdome begalini while ciklą.
                        }
                        else   //na, o jei prie seką, ar po jos nėra skyriklio
                        {
                            e = e.Substring(pr + 1);    //iš redaguojamos eilutės atkerpame pradžią iki turimos sekos pradžios simbolio + 1 pozicija. Ta viena pozicija tam, kad sekančio ieškojimo metu nerastų to paties žodžio, kitaip sakant panaikiname tos sekos pirmą raidę.
                            poz += pr + 1; //išsaugome nukirptų simbolių skaičių, kurį naudosime poto.
                        }
                    }
                    break;
                }
        }
    }
}