INDEX 1,3,4

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
    {
        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()
        {
            Console.WriteLine("{0,-40} {1,5} {2,3}", name, year, rank);
            if (!active)
            {
                Program.RedLn("В корзине.\n");
            }
        }
    }
    [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 = Path.Combine(Environment.CurrentDirectory, "contestants.dat");
        static string indexPath = Path.Combine(Environment.CurrentDirectory, "index.dat");
        public static void RedLn(string str) // вывести переданную строку красным цветом
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(str);
            Console.ResetColor();
        }
        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 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[] 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 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 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 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 byte[] arrayOfSerialized(IndexEntry entry)           // этот массив нужно будет писать в файл ИНДЕКСОВ
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            byte[] data = new byte[127];                            // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, entry);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;                    // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length);   // в массив с первой ячейки все из сериализованной записи из памяти
            return data;
        }

        static void UpdateIndex(IndexEntry[] entryArray) // обновить файл индексов
        {
            string path = Path.Combine(Environment.CurrentDirectory, "index.dat");
            var fs = new FileStream(path, FileMode.Truncate, FileAccess.Write);
            fs.Close();
            for (int i = 0; i < entryArray.Length; i++)
            {
                entryArray[i].Show();
                AddToEndOfFile(entryArray[i]); // тут можно перезаписать не весь, а только обновленную часть
            }
        }
        static void ListAllRecords() // вывести все записи БД
        {
            Console.Clear();
            Console.WriteLine("{0,-42} {1,5} {2,9}", "№  ФИО", "Год", "Разряд");
            var formatter = new BinaryFormatter();
            var fs = new FileStream(dbPath, FileMode.Open, FileAccess.Read);

            for (int i = 0; i < fs.Length / 255; i++)
            {
                var memoryStream = new MemoryStream();
                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);    // десериализуем
                Console.Write(i + 1 + ". ");
                person.Show();
            }

            fs.Close();
            Console.WriteLine("\nНажмите любую клавишу.");
            Console.ReadKey();
            Console.Clear();
        }
        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 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);
            fs.Close();
            return flag;
        }
        static void Main()
        {
            int act;
            int exit = 2;
            do
            {
                IndexEntry entry;
                Person person;
                Console.WriteLine("1. Добавить участника");
                if (File.Exists(dbPath))
                {
                    Console.WriteLine("2. Изменить информацию об участнике");
                    Console.WriteLine("3. Найти участника по ФИО");
                    Console.WriteLine("4. Вывести список всех участников");

                    Console.WriteLine("5. Удалить участника");
                    exit = 6;
                }
                Console.WriteLine(exit + ". Выход");
                act = AskForAction(exit);

                switch (act)
                {
                    case 1:
                        person = AskForNewPerson();                                  // запрос новой записи
                        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 - запись индексов
                        //byte[] ar2 = arrayOfSerialized(entry);                              //ar2 - массив с сер. entry [128]
                        AddToEndOfFile(person);
                        AddToIndexes(entry);
                        break;
                    case 3:
                        int counter = 0;
                        Console.Clear();
                        Console.Write("Введите ФИО для поиска: ");
                        string request = Console.ReadLine();
                        int firstEntryOfRequestedKey = PositionOfFirstAskedEntry(ArrayOfEntries(), request);
                        if (firstEntryOfRequestedKey != -1)
                        {
                            Console.Clear();
                            Console.WriteLine("По запросу \"{0}\" найдены записи:\n",request);
                            Console.WriteLine("{0,-42} {1,5} {2,9}", "№  ФИО", "Год", "Разряд");
                            int currentEjectNumber = firstEntryOfRequestedKey;
                            entry = EjectEntry(currentEjectNumber);
                            int position = entry.offset;
                            person = EjectPerson(position / 255);
                            Console.Write(++counter + ". ");
                            person.Show();
                            while (NextEntryOK(currentEjectNumber, request))
                            {
                                Console.Write(++counter + ". ");
                                EjectPerson(EjectEntry(++currentEjectNumber).offset / 255).Show();
                            }
                            Console.WriteLine("\nНажмите любую клавишу.");
                            Console.ReadKey();
                            Console.Clear();
                        }
                        else
                        {
                            Console.Clear();
                            Console.WriteLine("По запросу \"{0}\" ни одной записи не найдено.", request);
                            Console.WriteLine("\nНажмите любую клавишу.");
                            Console.ReadKey();
                            Console.Clear();
                        }

                        //Console.WriteLine(PositionOfFirstAskedEntry(ArrayOfEntries(), Console.ReadLine()));
                        break;
                    case 4:
                        ListAllRecords();
                        break;
                }

            } while (act != exit);
        }
    }

}