INDEX Wed

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;


namespace ConsoleApplication2
{
    [Serializable]
    public struct Person
    {
        public bool active;
        public string name;
        public int year;
        public int rank;
        public Person(bool _active, string _name, int _year, int _rank)
        {
            active = _active;
            name = _name;
            year = _year;
            rank = _rank;
        }
        public void Show()
        {
            //if (active)
            //{
            Console.WriteLine("{0,-40} {1,5} {2,3}", name, year, rank);
            //}
        }
    }
    [Serializable]
    public struct IndexEntry
    {
        public string key;
        public int length;
        public int offset;
        public IndexEntry(string _key, int _length, int _offset)
        {
            key = _key;
            length = _length;
            offset = _offset;
        }
        public void Show()
        {
            Console.WriteLine("{0,-40} {1} {2}", key, length, offset);
        }
    }
    class Program
    {
        static string dbPath;
        static string indexPath;
        static IndexEntry[] AddIndexEntryToArray(IndexEntry[] array, IndexEntry entryToAdd)
        {
            var newArray = new IndexEntry[array.Length + 1];
            int i = 0;
            for (i = 0; i < array.Length; i++)
            {
                newArray[i] = array[i];
            }
            newArray[i] = entryToAdd;
            return newArray;
        }
        static Person[] AddPersonToArray(Person[] array, Person personToAdd)
        {
            var newArray = new Person[array.Length + 1];
            int i = 0;
            for (i = 0; i < array.Length; i++)
            {
                newArray[i] = array[i];
            }
            newArray[i] = personToAdd;
            return newArray;
        }
        static void AddToEndOfFile(Person person)                               // добавить переданную запись в конец БД
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            var fs = new FileStream(dbPath, FileMode.OpenOrCreate, FileAccess.Write); // добавление записи в файл
            fs.Seek(0, SeekOrigin.End);
            BinaryWriter bw = new BinaryWriter(fs);
            byte[] data = new byte[255];                // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, person);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;        // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length); // в массив с первой ячейки все из сериализованной записи из памяти
            bw.Write(data);                             // запись массива байтов в конец файла
            fs.Close();
        }
        static void AddToEndOfFile(IndexEntry entry)                            // добавить переданную запись в конец индексов
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            var fs = new FileStream(indexPath, FileMode.OpenOrCreate, FileAccess.Write); // добавление записи в файл
            fs.Seek(0, SeekOrigin.End);
            BinaryWriter bw = new BinaryWriter(fs);
            byte[] data = new byte[255];                // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, entry);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;        // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length); // в массив с первой ячейки все из сериализованной записи из памяти
            bw.Write(data);                             // запись массива байтов в конец файла
            fs.Close();
        }
        static void AddToIndexes(IndexEntry entry)
        {
            var fs = new FileStream(dbPath, FileMode.Open, FileAccess.Read);
            fs.Position = 0;
            if ((int)fs.Length == 255)                                              // если в базе 1 запись -
            {
                AddToEndOfFile(entry);                                              // пишем в конец индексов;
            }
            else                                                                    // если больше одной  -
            {
                bool done = false;
                var entryArray = new IndexEntry[(int)fs.Length / 255];
                int counter = 0;
                int i = 0;
                while (i < fs.Length / 255 - 1)
                {
                    IndexEntry ejected = EjectEntry(i);
                    int comp = ejected.key.CompareTo(entry.key);                // ej<en= -1 ej=en =0 ej>en=1
                    if (comp == -1 || comp == 0)                                             // ФИО извлеченной записи < ФИО введенной
                    {
                        entryArray[counter++] = ejected;
                    }
                    else
                    {
                        if (!done)
                        {
                            entryArray[counter++] = entry;
                            done = true;
                        }
                        entryArray[counter++] = ejected;
                    }
                    i++;
                }
                if (!done)
                {
                    entryArray[counter] = entry;
                }

                UpdateIndex(entryArray);
            }
            fs.Close();
        }
        static int[] AddToIntArray(int[] array, int toAdd)
        {
            int i = 0;
            int[] newArray = new int[array.Length + 1];
            for (i = 0; i < array.Length; i++)
            {
                newArray[i] = array[i];
            }
            newArray[i] = toAdd;
            return newArray;
        }
        static byte[] ArrayOfSerialized(Person person)                          // этот массив нужно будет писать в файл БД
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            byte[] data = new byte[255];                            // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, person);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;                    // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length);   // в массив с первой ячейки все из сериализованной записи из памяти
            return data;                                                    // этот массив нужно будет писать в файл
        }
        static IndexEntry[] ArrayOfEntries()
        {
            var fs = new FileStream(indexPath, FileMode.Open, FileAccess.Read);
            var array = new IndexEntry[fs.Length / 255];
            for (int i = 0; i < fs.Length / 255; i++)
            {
                array[i] = EjectEntry(i);
            }
            fs.Close();
            return (array);
        }
        static int AskForAction(int qtyOfActions)                               // запросить команду меню с проверкой вводимых значений
        {
            int act;
            bool ok;
            Console.WriteLine();
            do
            {
                Console.Write("Команда: ");
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out act) && act > 0 && act <= qtyOfActions;
                if (!ok)
                    RedLn("Доступны команды 1 - " + qtyOfActions + ".");
            } while (!ok);
            Console.WriteLine();
            return act;
        }
        static Person AskForNewPerson()                                         // запросить нового участника, создать и вернуть запись
        {
            Console.Clear();
            string name;
            int year, rank;
            bool ok;
            Console.Write("ФИО: ");                         // ввод ФИО
            name = Console.ReadLine();
            int tempParse;
            do                                              // ввод года
            {
                Console.Write("Год рождения: ");
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out tempParse) && tempParse > 1900 && tempParse < 2015;
                if (!ok)
                {
                    RedLn("Ошибка.");
                    Console.WriteLine("Убедитесь в правильности введенного года рождения и повторите ввод.\n");
                }
            } while (!ok);
            year = tempParse;
            do                                              // ввод разряда
            {
                Console.Write("Текущий разряд: ");
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out tempParse) && tempParse >= 0 && tempParse < 10;
                if (!ok)
                {
                    RedLn("Ошибка.");
                    Console.WriteLine("Убедитесь в правильности введенного разряда и повторите ввод.\n");
                }
            } while (!ok);
            rank = tempParse;
            return new Person(true, name, year, rank);      // конец ввода данных и возврат записи
        }
        static void ChangePerson(int number, Person person)
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            var fs = new FileStream(dbPath, FileMode.Open, FileAccess.Write); // добавление записи в файл
            fs.Position = number * 255;
            BinaryWriter bw = new BinaryWriter(fs);
            byte[] data = new byte[255];                // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, person);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;        // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length); // в массив с первой ячейки все из сериализованной записи из памяти
            bw.Write(data);                             // запись массива байтов в конец файла
            fs.Close();
        }
        static void ChangeIndex(int number, IndexEntry entry)
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            var fs = new FileStream(indexPath, FileMode.Open, FileAccess.Write); // добавление записи в файл
            fs.Position = number * 255;
            BinaryWriter bw = new BinaryWriter(fs);
            byte[] data = new byte[255];                // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, entry);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;        // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length); // в массив с первой ячейки все из сериализованной записи из памяти
            bw.Write(data);                             // запись массива байтов в конец файла
            fs.Close();
        }
        static bool CheckSize(string path1, string path2)
        {
            var fs = new FileStream(path1, FileMode.Open, FileAccess.Read);
            int size1 = (int)fs.Length;
            fs.Close();
            fs = new FileStream(path2, FileMode.Open, FileAccess.Read);
            bool ok = (int)fs.Length == size1;
            fs.Close();
            return ok;
        }
        static Person EjectPerson(int i)                                        // извлечь указанную запись
        {
            var formatter = new BinaryFormatter();
            var fs = new FileStream(dbPath, FileMode.Open, FileAccess.Read);
            var memoryStream = new MemoryStream();
            fs.Position = i * 255;
            var data = new byte[255];                                       // объявить массив под сериализованную запись
            fs.Read(data, 0, 255);                                          // считать в массив всю запись
            memoryStream.Write(data, 1, data[0]);                           // значимые байты записи - в ОЗУ
            memoryStream.Position = 0;
            Person person = (Person)formatter.Deserialize(memoryStream);    // десериализовать запись из байтов записи
            fs.Close();
            return person;                                                  // вернуть запись
        }
        static IndexEntry EjectEntry(int i)                                     // извлечь указанную запись
        {
            var formatter = new BinaryFormatter();
            var fs = new FileStream(indexPath, FileMode.Open, FileAccess.Read);
            var memoryStream = new MemoryStream();
            fs.Position = i * 255;
            var data = new byte[255];                                       // объявить массив под сериализованную запись
            fs.Read(data, 0, 255);                                          // считать в массив всю запись
            memoryStream.Write(data, 1, data[0]);                           // значимые байты записи - в ОЗУ
            memoryStream.Position = 0;
            IndexEntry entry = (IndexEntry)formatter.Deserialize(memoryStream);    // десериализовать запись из байтов записи
            fs.Close();
            return entry;                                                  // вернуть запись
        }
        static IndexEntry[] FindEntriesWithRequestedKeys(string request)        // создает массив найденных по ключу-ФИО записей индексов либо возврящает нулевую ссылку
        {
            IndexEntry[] array = new IndexEntry[0];
            int position = PositionOfFirstAskedEntry(ArrayOfEntries(), request);
            IndexEntry entry;
            Person person = new Person();
            if (position != -1)
            {
                entry = EjectEntry(position);
                person = EjectPerson(entry.offset / 255);
            }

            if (position != -1 && person.active)
            {
                int currentEjectNumber = position;
                while (NextEntryOK(currentEjectNumber - 1, request))
                {
                    array = AddIndexEntryToArray(array, EjectEntry(currentEjectNumber++));
                }
                return array;
            }
            else
            {
                return null;
            }
        }
        static IndexEntry[] FindEntriesWithRequestedKeys(string request, ref int[] positionsArray)                // создает массив найденных по ключу-ФИО записей индексов либо возврящает нулевую ссылку
        {
            positionsArray = new int[0];
            IndexEntry[] array = new IndexEntry[0];
            int position = PositionOfFirstAskedEntry(ArrayOfEntries(), request);
            IndexEntry entry;
            Person person = new Person();
            if (position != -1)
            {
                entry = EjectEntry(position);

                person = EjectPerson(entry.offset / 255);
            }

            if (position != -1 && person.active)
            {
                int currentEjectNumber = position;
                while (NextEntryOK(currentEjectNumber - 1, request))
                {
                    array = AddIndexEntryToArray(array, EjectEntry(currentEjectNumber));
                    positionsArray = AddToIntArray(positionsArray, currentEjectNumber++);
                }
                return array;
            }
            else
            {
                return null;
            }
        }
        static void KillDeleted(int[] arrayOfPositions)
        {

        }
        static bool NextEntryOK(int entryNumber, string request)
        {
            bool flag = false;
            var formatter = new BinaryFormatter();
            var fs = new FileStream(indexPath, FileMode.Open, FileAccess.Read);
            flag = (entryNumber + 1 != fs.Length / 255) && (EjectEntry(entryNumber + 1).key == request) && (EjectPerson(EjectEntry(entryNumber + 1).offset / 255).active == true);
            fs.Close();
            return flag;
        }
        static IndexEntry[] MarkedDeleted(ref int[] positionsArray)                                     // создает массив индексов удаленных записей
        {
            positionsArray = new int[0];
            IndexEntry[] array = new IndexEntry[0];
            var entry = new IndexEntry();
            var person = new Person();
            var fs = new FileStream(indexPath, FileMode.Open, FileAccess.Read);
            int size = (int)fs.Length / 255;
            fs.Close();
            for (int i = 0; i < size; i++)
            {
                entry = EjectEntry(i);
                int number = entry.offset / 255;
                person = EjectPerson(number);
                if (!person.active)
                {
                    array = AddIndexEntryToArray(array, entry);
                    positionsArray = AddToIntArray(positionsArray, i);
                }
            }
            if (array.Length != 0)
            {
                return array;
            }
            else
            {
                return null;
            }
        }
        static void ListAllRecords() // вывести все записи БД
        {
            Console.Clear();
            var formatter = new BinaryFormatter();
            var fs = new FileStream(dbPath, FileMode.Open, FileAccess.Read);
            bool unmarkedPersonExists = false;
            for (int i = 0; i < fs.Length / 255; i++)
            {
                unmarkedPersonExists = unmarkedPersonExists | EjectPerson(i).active;
            }
            if (unmarkedPersonExists)
            {
                Console.WriteLine("{0,-42} {1,5} {2,9}", "№  ФИО", "Год", "Разряд");
                var ifs = new FileStream(indexPath, FileMode.Open, FileAccess.Read);
                int counter = 0;
                for (int i = 0; i < ifs.Length / 255; i++)
                {
                    var memoryStream = new MemoryStream();
                    var data = new byte[255];                                               // объявить массив под сериализованную запись
                    ifs.Read(data, 0, 255);                                                 // считать в массив всю запись
                    memoryStream.Write(data, 1, data[0]);                                   // значимые байты записи - в ОЗУ
                    memoryStream.Position = 0;
                    IndexEntry entry = (IndexEntry)formatter.Deserialize(memoryStream);
                    memoryStream = new MemoryStream();
                    data = new byte[255];                                                   // объявить массив под сериализованную запись
                    fs.Position = entry.offset;
                    fs.Read(data, 0, 255);                                                  // считать в массив всю запись
                    memoryStream.Write(data, 1, data[0]);                                   // значимые байты записи - в ОЗУ
                    memoryStream.Position = 0;
                    Person person = (Person)formatter.Deserialize(memoryStream);
                    if (person.active)
                    {
                        Console.Write(++counter + ". ");
                        person.Show();
                    }
                }
                ifs.Close();
            }
            else
            {
                Console.WriteLine("База данных пуста.\n");
            }
            fs.Close();

            Console.WriteLine("\nНажмите любую клавишу.");
            Console.ReadKey();
            Console.Clear();
        }
        static int ListAllDeletedRecords(ref int[] positionsArray)
        {
            positionsArray = new int[0];
            int quantity = 0;
            Console.Clear();
            IndexEntry[] array = MarkedDeleted(ref positionsArray);
            if (array != null)
            {
                Console.WriteLine("Были удалены следующие записи:\n");
                Console.WriteLine("{0,-42} {1,5} {2,8}", "№  ФИО", "Год", "Разряд");
                for (int i = 0; i < array.Length; i++)
                {
                    Console.Write(i + 1 + ". ");
                    EjectPerson(array[i].offset / 255).Show();
                    quantity++;
                }

            }
            else
            {
                Console.WriteLine("Ни одной записи не было удалено либо записи были удалены безвозвратно.\n");
            }
            return quantity;
        }
        static int PositionOfFirstAskedEntry(IndexEntry[] array, string key)    // бинарный поиск первого вхождения записи с запрошенным полем в БД
        {
            int left = 0, right = array.Length - 1;
            int middle;
            do
            {
                middle = (left + right) / 2;
                if (array[middle].key.CompareTo(key) == -1)
                {
                    left = middle + 1;
                }
                else
                {
                    right = middle;
                }
            } while (left != right);
            if (array[left].key == key)
            {
                return left;
            }
            return (-1);
        }
        static void RearrangeIndexWith(int positionOfOld, IndexEntry newEntry)
        {

            IndexEntry[] oldArray;
            oldArray = ArrayOfEntries();
            IndexEntry[] newArray = new IndexEntry[oldArray.Length - 1];
            int counter = 0;
            for (int i = 0; i < oldArray.Length; i++)
            {
                if (i != positionOfOld)
                {
                    newArray[counter] = oldArray[i];
                    counter++;
                }
            }
            UpdateIndex(newArray);
            AddToIndexes(newEntry);
        }
        public static void RedLn(string str)                                    // вывести переданную строку красным цветом
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(str);
            Console.ResetColor();
        }
        static void UpdateIndex(IndexEntry[] entryArray)                        // обновить файл индексов
        {
            var fs = new FileStream(indexPath, FileMode.Truncate, FileAccess.Write);
            fs.Close();
            for (int i = 0; i < entryArray.Length; i++)
            {
                //entryArray[i].Show();
                AddToEndOfFile(entryArray[i]); // тут можно перезаписать не весь, а только обновленную часть
            }
        }

        static void Main()
        {
            int act;
            int exit = 2;
            bool ok = false;
            int chosenPerson;
            int chosenEntry;
            bool openFlag = true;
            bool rewriteError = false;
            string name = "";
            string path = "";
            string fileNotFoundName = "";
            do
            {
                if (!openFlag && !rewriteError)
                {
                    Console.Clear();
                    Console.WriteLine("\nОшибка. Файл \"{0}\" не найден.\nНажмите любую клавишу", fileNotFoundName);
                    Console.ReadKey();
                    Console.Clear();
                }
                openFlag = true;
                rewriteError = false;
                Console.WriteLine("1. Открыть файл");
                Console.WriteLine("2. Создать файл");
                Console.WriteLine("3. Выход");
                act = AskForAction(3);
                switch (act)
                {
                    case 1:
                        Console.WriteLine("Убедитесь, что файлы находился в папке ConsoleApplication3/bin/Debug\n");
                        Console.Write("Введите имя файла БД: ");
                        name = Console.ReadLine();
                        path = Path.Combine(Environment.CurrentDirectory, name);
                        if (!File.Exists(path))
                        {
                            fileNotFoundName = name;
                            openFlag = false;
                        }
                        if (openFlag)
                        {
                            dbPath = path;
                            Console.Write("Введите имя файла индексов: ");
                            name = Console.ReadLine();
                            path = Path.Combine(Environment.CurrentDirectory, name);
                            if (!File.Exists(path))
                            {
                                fileNotFoundName = name;
                                openFlag = false;
                            }
                            if (openFlag)
                            {
                                indexPath = path;
                            }
                        }
                        if (openFlag)
                        {
                            ok = CheckSize(dbPath, indexPath);
                            if (!ok)
                            {
                                RedLn("Ошибка. Убедитесь, что вы открываете два связанных файла");
                                Console.ReadKey();
                                Console.Clear();
                            }
                        }
                        break;
                    case 2:
                        do
                        {
                            Console.Write("Введите имя файла БД без расширения: ");
                            name = Console.ReadLine();
                            ok = !name.Contains('.') && !name.Contains(',') && !name.Contains('*') && !name.Contains(':') && !name.Contains('?') && !name.Contains('!') && !name.Contains('@');
                            if (!ok)
                            {
                                RedLn("Имя файла не должно содержать символов .,;:?!@");
                            }
                        } while (!ok);
                        name += ".dat";
                        dbPath = Path.Combine(Environment.CurrentDirectory, name);

                        do
                        {
                            Console.Write("Введите имя файла индексов без расширения: ");
                            name = Console.ReadLine();
                            ok = !name.Contains('.') && !name.Contains(',') && !name.Contains('*') && !name.Contains(':') && !name.Contains('?') && !name.Contains('!') && !name.Contains('@');
                            if (!ok)
                            {
                                RedLn("Имя файла не должно содержать символов .,;:?!@");
                            }
                        } while (!ok);
                        name += ".dat";
                        indexPath = Path.Combine(Environment.CurrentDirectory, name);
                        if (indexPath == dbPath)
                        {
                            Console.Clear();
                            Console.WriteLine("\nОшибка. Вы только что перезаписали один файл другим. Так не пойдет. \n\nНажмите любую клавишу", fileNotFoundName);
                            Console.ReadKey();
                            Console.Clear();
                            openFlag = false;
                            rewriteError = true;
                        }
                        else
                        {
                            openFlag = true;
                        }
                        break;
                }
            } while (act != 3 && !openFlag);

            if (act != 3)
            {
                do
                {
                    ok = false;
                    IndexEntry entry;
                    Person person;
                    Console.Clear();
                    Console.WriteLine("1. Добавить участника");
                    if (File.Exists(dbPath))
                    {
                        Console.WriteLine("2. Вывести список всех участников");
                        Console.WriteLine("3. Найти участника по ФИО");
                        Console.WriteLine("4. Редактировать запись участника");
                        Console.WriteLine("5. Удалить запись участника");
                        Console.WriteLine("6. Показать недавно удаленных участников");
                        exit = 7;
                    }
                    Console.WriteLine(exit + ". Выход");
                    act = AskForAction(exit);

                    switch (act)
                    {
                        case 1:
                            person = AskForNewPerson();                                         // запрос новой записи
                            //person = new Person(false, "Анна", 1995, 5);
                            Console.Clear();
                            var fs = new FileStream(dbPath, FileMode.OpenOrCreate, FileAccess.Read);
                            int offset = (int)fs.Length;                                        // offset - номер байта, начиная с которого в файле хранится запись
                            fs.Close();
                            byte[] ar1 = ArrayOfSerialized(person);                             // ar1 - массив с сер. person [255]
                            int length = ar1[0];                                                // length - длина сер. person
                            entry = new IndexEntry(person.name, length, offset);                // entry - запись индексов
                            AddToEndOfFile(person);
                            AddToIndexes(entry);
                            break;
                        case 2:
                            ListAllRecords();
                            break;
                        case 3:
                            Console.Clear();
                            Console.Write("Введите ФИО для поиска: ");
                            string request = Console.ReadLine();
                            var arrayOfFoundEntries = FindEntriesWithRequestedKeys(request);
                            if (arrayOfFoundEntries == null)
                            {
                                Console.Clear();
                                Console.WriteLine("По запросу \"{0}\" ни одной записи не найдено.", request);
                                Console.WriteLine("\nНажмите любую клавишу.");
                                Console.ReadKey();
                                Console.Clear();
                            }
                            else
                            {
                                Console.Clear();
                                Console.WriteLine("По запросу \"{0}\" найдены записи:\n", request);
                                Console.WriteLine("{0,-42} {1,5} {2,9}", "№  ФИО", "Год", "Разряд");
                                for (int i = 0; i < arrayOfFoundEntries.Length; i++)
                                {
                                    Console.Write(i + 1 + ". ");
                                    EjectPerson(arrayOfFoundEntries[i].offset / 255).Show();
                                }
                                Console.WriteLine("\nНажмите любую клавишу.");
                                Console.ReadKey();
                                Console.Clear();
                            }
                            break;
                        case 4:
                            Console.Clear();
                            Console.Write("Редактировать участника с ФИО: ");
                            string key1 = Console.ReadLine();
                            int[] arrayOfPositions = new int[0];
                            IndexEntry[] array1 = FindEntriesWithRequestedKeys(key1, ref arrayOfPositions);
                            if (array1 == null)
                            {
                                Console.Clear();
                                Console.WriteLine("По запросу \"{0}\" ни одной записи не найдено.", key1);
                                Console.WriteLine("\nНажмите любую клавишу.");
                                Console.ReadKey();
                                Console.Clear();
                            }
                            else
                            {
                                Console.Clear();
                                Console.WriteLine("По запросу \"{0}\" найдены записи:\n", key1);
                                Console.WriteLine("{0,-42} {1,5} {2,9}", "№  ФИО", "Год", "Разряд");
                                for (int i = 0; i < array1.Length; i++)
                                {
                                    Console.Write(i + 1 + ". ");
                                    EjectPerson(array1[i].offset / 255).Show();
                                }
                                do
                                {
                                    Console.Write("\nРедактировать запись № ");
                                    string buf = Console.ReadLine();
                                    ok = int.TryParse(buf, out chosenPerson) && chosenPerson > 0 && chosenPerson <= array1.Length;
                                    if (!ok)
                                    {
                                        RedLn("Ошибка.");
                                        Console.WriteLine("Ожидалось число {0}-{1}.", 1, array1.Length);
                                    }
                                } while (!ok);
                                chosenEntry = arrayOfPositions[chosenPerson - 1];                   // получаем положение удаляемой записи в индексах(порядковый номер в файле)
                                chosenPerson = array1[chosenPerson - 1].offset / 255;               // получаем номер удаляемой записи в БД (порядковый номер в файле)
                                //Console.WriteLine("Alert 616 - " + chosenEntry + chosenPerson);
                                int action = 0;
                                Person personToEdit;
                                IndexEntry entryToEdit;
                                do
                                {
                                    Console.Clear();
                                    string newData;
                                    personToEdit = EjectPerson(chosenPerson);
                                    entryToEdit = EjectEntry(chosenEntry);
                                    Console.WriteLine("1. Изменить ФИО ({0})\n2. Изменить год рождения ({1})\n3. Изменить разряд ({2})\n4. В меню\n", personToEdit.name, personToEdit.year, personToEdit.rank);
                                    action = AskForAction(4);
                                    switch (action)
                                    {
                                        case 1:
                                            Console.Clear();
                                            Console.WriteLine("Старые данные: {0}", personToEdit.name);
                                            Console.Write("Новые данные: ");
                                            newData = Console.ReadLine();
                                            personToEdit.name = newData;
                                            entryToEdit.key = newData;
                                            ChangePerson(chosenPerson, personToEdit);
                                            RearrangeIndexWith(chosenEntry, entryToEdit);
                                            //ChangeIndex(chosenEntry, entryToEdit);
                                            Console.WriteLine("\nЗапись изменена. Нажмите любую клавишу.");
                                            Console.ReadKey();
                                            Console.Clear();
                                            break;
                                        case 2:
                                            int newYear;
                                            Console.Clear();
                                            Console.WriteLine("Старые данные: {0}", personToEdit.name);
                                            do
                                            {
                                                Console.Write("Новые данные: ");
                                                newData = Console.ReadLine();
                                                ok = int.TryParse(newData, out newYear) && newYear > 1900 && newYear < 2015;
                                                if (!ok)
                                                {
                                                    RedLn("Ошибка.");
                                                    Console.WriteLine("Убедитесь в правильности введенного года и повторите ввод.\n");
                                                }
                                            } while (!ok);
                                            personToEdit.year = newYear;
                                            ChangePerson(chosenPerson, personToEdit);
                                            Console.WriteLine("\nЗапись изменена. Нажмите любую клавишу.");
                                            Console.ReadKey();
                                            Console.Clear();
                                            break;
                                        case 3:
                                            Console.Clear();
                                            Console.WriteLine("Старые данные: {0}", personToEdit.name);
                                            do
                                            {
                                                Console.Write("Новые данные: ");
                                                newData = Console.ReadLine();
                                                ok = int.TryParse(newData, out newYear) && newYear >= 0 && newYear < 10;
                                                if (!ok)
                                                {
                                                    RedLn("Ошибка.");
                                                    Console.WriteLine("Убедитесь в правильности введенного разряда и повторите ввод.\n");
                                                }
                                            } while (!ok);
                                            personToEdit.rank = newYear;
                                            ChangePerson(chosenPerson, personToEdit);
                                            Console.WriteLine("\nЗапись изменена. Нажмите любую клавишу.");
                                            Console.ReadKey();
                                            Console.Clear();
                                            break;
                                        case 4:
                                            break;
                                    }
                                } while (action != 4);
                                Console.Clear();
                            }
                            break;
                        case 5:
                            Console.Clear();
                            Console.Write("Удалить участника с ФИО: ");
                            string key = Console.ReadLine();
                            var array = FindEntriesWithRequestedKeys(key);
                            if (array == null)
                            {
                                Console.Clear();
                                Console.WriteLine("По запросу \"{0}\" ни одной записи не найдено.", key);
                                Console.WriteLine("\nНажмите любую клавишу.");
                                Console.ReadKey();
                                Console.Clear();
                            }
                            else
                            {
                                Console.Clear();
                                Console.WriteLine("По запросу \"{0}\" найдены записи:\n", key);
                                Console.WriteLine("{0,-42} {1,5} {2,9}", "№  ФИО", "Год", "Разряд");
                                for (int i = 0; i < array.Length; i++)
                                {
                                    Console.Write(i + 1 + ". ");
                                    EjectPerson(array[i].offset / 255).Show();
                                }
                                do
                                {
                                    Console.Write("\nУдалить запись № ");
                                    string buf = Console.ReadLine();
                                    ok = int.TryParse(buf, out chosenPerson) && chosenPerson > 0 && chosenPerson <= array.Length;
                                    if (!ok)
                                    {
                                        RedLn("Ошибка.");
                                        Console.WriteLine("Ожидалось число {0}-{1}.", 1, array.Length);
                                    }
                                } while (!ok);
                                Console.Clear();
                                chosenPerson = array[chosenPerson - 1].offset / 255; // получаем номер подлежащей удалению (пометке об удалении) записи в БД
                                Person personToMark = EjectPerson(chosenPerson);
                                personToMark.active = false;
                                ChangePerson(chosenPerson, personToMark);
                                Console.WriteLine("\nЗапись удалена. Нажмите любую клавишу.");
                                Console.ReadKey();
                                Console.Clear();
                            }

                            break;
                        case 6:
                            arrayOfPositions = new int[0];
                            IndexEntry[] arrayOfDeleted = new IndexEntry[0];
                            int quantity = ListAllDeletedRecords(ref arrayOfPositions);                 // вывод удаленных записей и возврат их количества в quantity
                            if (quantity > 0)
                            {
                                Console.WriteLine("\n1. Очистить корзину\n2. Восстановить записи\n3. В меню");
                                int case3act = AskForAction(3);
                                switch (case3act)
                                {
                                    case 1:
                                        arrayOfDeleted = MarkedDeleted(ref arrayOfPositions);
                                        KillDeleted(arrayOfPositions);
                                        break;
                                    case 2:
                                        arrayOfDeleted = MarkedDeleted(ref arrayOfPositions);
                                        do
                                        {
                                            Console.Write("Восстановить запись № ");
                                            string buf = Console.ReadLine();
                                            ok = int.TryParse(buf, out chosenPerson) && chosenPerson > 0 && chosenPerson <= arrayOfDeleted.Length;
                                            if (!ok)
                                            {
                                                RedLn("Ошибка.");
                                                Console.WriteLine("Ожидалось число {0}-{1}.\n", 1, arrayOfDeleted.Length);
                                            }
                                        } while (!ok);
                                        int number = arrayOfDeleted[chosenPerson - 1].offset / 255;
                                        person = EjectPerson(number);
                                        person.active = true;
                                        ChangePerson(number, person);
                                        Console.Clear();
                                        Console.Write("\nЗапись восстановлена. Нажмите любую клавишу.");
                                        Console.ReadKey();
                                        Console.Clear();
                                        break;
                                    case 3:
                                        Console.Clear();
                                        break;
                                }
                            }
                            else
                            {
                                Console.WriteLine("\nНажмите любую клавишу.");
                                Console.ReadKey();
                                Console.Clear();
                            }
                            break;
                    }
                } while (act != exit);
            }
        }
    }
}