ExplanatoryDictionary_v3

using System;
using System.Collections.Generic;
using System.Text;

enum MessageId
{
    Title,
    InputPrompt,
    EmptyInput,
    WordNotFound,
    ProgramEnded,
    Border,
    Header,
    Help,

    Added,
    AlreadyExistsUpdated,
    ListEmpty,

    EnterEnglish,
    EnterRussian,
    InvalidAdd,

    ListTitle,

    EnterWordToDelete,
    Deleted,
    DeleteNotFound,

    EnterWordToEdit,
    EnterNewTranslation,
    Edited,
    EditNotFound,
    InvalidEditSame
}

class Program
{
    private static readonly Dictionary<MessageId, string> Messages = CreateMessages();

    public static void Main()
    {
        Work();
    }

    private static void Work()
    {
        Console.Clear();
        Console.OutputEncoding = Encoding.UTF8;
        Console.Title = Messages[MessageId.Title];

        (Dictionary<string, string> engToRus, Dictionary<string, string> rusToEng) = CreateDictionaries();

        PrintHeader();
        ShowInfo(Messages[MessageId.Help]);
        Console.WriteLine();

        bool isRunning = true;

        while (isRunning)
        {
            string input = RequestInput();

            if (IsExitCommand(input))
            {
                ShowInfo(Messages[MessageId.ProgramEnded]);
                isRunning = false;
                continue;
            }

            if (IsListCommand(input))
            {
                PrintList(engToRus);
                continue;
            }

            if (IsAddCommand(input))
            {
                HandleAdd(engToRus, rusToEng);
                continue;
            }

            if (IsDeleteCommand(input))
            {
                HandleDelete(engToRus, rusToEng);
                continue;
            }

            if (IsEditCommand(input))
            {
                HandleEdit(engToRus, rusToEng);
                continue;
            }

            ProcessQuery(engToRus, rusToEng, input);
        }
    }

    private static Dictionary<MessageId, string> CreateMessages()
    {
        return new Dictionary<MessageId, string>
        {
            { MessageId.Title, "ENG ⇄ RUS Dictionary" },

            {
                MessageId.InputPrompt,
                "Введите слово или команду (add/edit/delete/list/exit | добавить/редактировать/удалить/список/выход): "
            },

            { MessageId.EmptyInput, "Пустой ввод. Попробуйте снова." },
            { MessageId.WordNotFound, "Слово \"{0}\" не найдено в словаре." },
            { MessageId.ProgramEnded, "Программа завершена." },
            { MessageId.Border, "======================================" },
            { MessageId.Header, "        ENG ⇄ RUS Dictionary          " },
            { MessageId.ListTitle, "Список слов (ENG → RUS):" },

            {
                MessageId.Help,
                "Команды:\n" +
                "  add / добавить            — добавить пару слов\n" +
                "  edit / редактировать      — изменить перевод\n" +
                "  delete / удалить          — удалить слово\n" +
                "  list / список             — показать все слова\n" +
                "  exit / выход              — выйти\n" +
                "Можно также просто вводить слово для перевода."
            },

            { MessageId.Added, "Пара добавлена." },
            { MessageId.AlreadyExistsUpdated, "Слово/перевод уже существовали — запись обновлена." },
            { MessageId.ListEmpty, "Словарь пуст." },

            { MessageId.EnterEnglish, "Введите английское слово: " },
            { MessageId.EnterRussian, "Введите русский перевод: " },
            { MessageId.InvalidAdd, "Некорректная пара (слова совпадают)." },

            { MessageId.EnterWordToDelete, "Введите слово для удаления (ENG или RUS): " },
            { MessageId.Deleted, "Удалено: {0}" },
            { MessageId.DeleteNotFound, "Не найдено для удаления: \"{0}\"" },

            { MessageId.EnterWordToEdit, "Введите слово для редактирования (ENG или RUS): " },
            { MessageId.EnterNewTranslation, "Введите новый перевод: " },
            { MessageId.Edited, "Обновлено: {0} → {1}" },
            { MessageId.EditNotFound, "Не найдено для редактирования: \"{0}\"" },
            { MessageId.InvalidEditSame, "Некорректно: слово и перевод совпадают." }
        };
    }

    private static (Dictionary<string, string> engToRus, Dictionary<string, string> rusToEng) CreateDictionaries()
    {
        var engToRus = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        var rusToEng = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

        var pairs = new (string Eng, string Rus)[]
        {
            ("apple", "яблоко"),
            ("book", "книга"),
            ("car", "машина"),
            ("house", "дом"),
            ("computer", "компьютер")
        };

        foreach (var (eng, rus) in pairs)
        {
            engToRus[eng] = rus;
            rusToEng[rus] = eng;
        }

        return (engToRus, rusToEng);
    }

    private static string RequestInput()
    {
        string? input;
        bool isValid;

        do
        {
            Console.Write(Messages[MessageId.InputPrompt]);
            input = Console.ReadLine();

            isValid = !string.IsNullOrWhiteSpace(input);

            if (!isValid)
            {
                ShowWarning(Messages[MessageId.EmptyInput]);
                Console.WriteLine();
            }

        } while (!isValid);

        return input!.Trim();
    }

    private static string RequestNonEmpty(string prompt)
    {
        string? input;

        do
        {
            Console.Write(prompt);
            input = Console.ReadLine();

            if (string.IsNullOrWhiteSpace(input))
                ShowWarning(Messages[MessageId.EmptyInput]);

        } while (string.IsNullOrWhiteSpace(input));

        return input.Trim();
    }

    private static void ProcessQuery(
        Dictionary<string, string> engToRus,
        Dictionary<string, string> rusToEng,
        string input)
    {
        bool isFound = TryFindTranslation(engToRus, rusToEng, input, out string result);

        if (isFound)
            ShowSuccess(result);
        else
            ShowError(string.Format(Messages[MessageId.WordNotFound], input));

        Console.WriteLine();
    }

    private static bool TryFindTranslation(
        Dictionary<string, string> engToRus,
        Dictionary<string, string> rusToEng,
        string input,
        out string result)
    {
        if (engToRus.TryGetValue(input, out string russianWord))
        {
            result = input + " → " + russianWord;
            return true;
        }

        if (rusToEng.TryGetValue(input, out string englishWord))
        {
            result = input + " → " + englishWord;
            return true;
        }

        result = string.Empty;
        return false;
    }

    private static bool IsAddCommand(string input) =>
        input.Equals("add", StringComparison.OrdinalIgnoreCase) ||
        input.Equals("добавить", StringComparison.OrdinalIgnoreCase);

    private static bool IsListCommand(string input) =>
        input.Equals("list", StringComparison.OrdinalIgnoreCase) ||
        input.Equals("список", StringComparison.OrdinalIgnoreCase);

    private static bool IsDeleteCommand(string input) =>
        input.Equals("delete", StringComparison.OrdinalIgnoreCase) ||
        input.Equals("удалить", StringComparison.OrdinalIgnoreCase);

    private static bool IsEditCommand(string input) =>
        input.Equals("edit", StringComparison.OrdinalIgnoreCase) ||
        input.Equals("редактировать", StringComparison.OrdinalIgnoreCase);

    private static bool IsExitCommand(string input) =>
        input.Equals("exit", StringComparison.OrdinalIgnoreCase) ||
        input.Equals("выход", StringComparison.OrdinalIgnoreCase);

    private static void HandleAdd(
        Dictionary<string, string> engToRus,
        Dictionary<string, string> rusToEng)
    {
        string eng = RequestNonEmpty(Messages[MessageId.EnterEnglish]);
        string rus = RequestNonEmpty(Messages[MessageId.EnterRussian]);

        if (eng.Equals(rus, StringComparison.OrdinalIgnoreCase))
        {
            ShowError(Messages[MessageId.InvalidAdd]);
            Console.WriteLine();
            return;
        }

        bool hadEng = engToRus.ContainsKey(eng);
        bool hadRus = rusToEng.ContainsKey(rus);

        if (hadEng)
        {
            string oldRus = engToRus[eng];

            if (!oldRus.Equals(rus, StringComparison.OrdinalIgnoreCase))
                rusToEng.Remove(oldRus);
        }

        if (hadRus)
        {
            string oldEng = rusToEng[rus];

            if (!oldEng.Equals(eng, StringComparison.OrdinalIgnoreCase))
                engToRus.Remove(oldEng);
        }

        engToRus[eng] = rus;
        rusToEng[rus] = eng;

        if (hadEng || hadRus)
            ShowWarning(Messages[MessageId.AlreadyExistsUpdated]);
        else
            ShowSuccess(Messages[MessageId.Added]);

        Console.WriteLine();
    }

    private static void HandleDelete(
        Dictionary<string, string> engToRus,
        Dictionary<string, string> rusToEng)
    {
        string word = RequestNonEmpty(Messages[MessageId.EnterWordToDelete]);

        if (engToRus.TryGetValue(word, out string rus))
        {
            engToRus.Remove(word);
            rusToEng.Remove(rus);

            ShowSuccess(string.Format(Messages[MessageId.Deleted], word));
            Console.WriteLine();
            return;
        }

        if (rusToEng.TryGetValue(word, out string eng))
        {
            rusToEng.Remove(word);
            engToRus.Remove(eng);

            ShowSuccess(string.Format(Messages[MessageId.Deleted], word));
            Console.WriteLine();
            return;
        }

        ShowError(string.Format(Messages[MessageId.DeleteNotFound], word));
        Console.WriteLine();
    }

    private static void HandleEdit(
        Dictionary<string, string> engToRus,
        Dictionary<string, string> rusToEng)
    {
        string word = RequestNonEmpty(Messages[MessageId.EnterWordToEdit]);

        if (engToRus.TryGetValue(word, out string oldRus))
        {
            string newRus = RequestNonEmpty(Messages[MessageId.EnterNewTranslation]);

            if (word.Equals(newRus, StringComparison.OrdinalIgnoreCase))
            {
                ShowError(Messages[MessageId.InvalidEditSame]);
                Console.WriteLine();
                return;
            }

            rusToEng.Remove(oldRus);

            if (rusToEng.TryGetValue(newRus, out string otherEng) &&
                !otherEng.Equals(word, StringComparison.OrdinalIgnoreCase))
            {
                engToRus.Remove(otherEng);
            }

            engToRus[word] = newRus;
            rusToEng[newRus] = word;

            ShowSuccess(string.Format(Messages[MessageId.Edited], word, newRus));
            Console.WriteLine();
            return;
        }

        if (rusToEng.TryGetValue(word, out string oldEng))
        {
            string newEng = RequestNonEmpty(Messages[MessageId.EnterNewTranslation]);

            if (word.Equals(newEng, StringComparison.OrdinalIgnoreCase))
            {
                ShowError(Messages[MessageId.InvalidEditSame]);
                Console.WriteLine();
                return;
            }

            engToRus.Remove(oldEng);

            if (engToRus.TryGetValue(newEng, out string otherRus) &&
                !otherRus.Equals(word, StringComparison.OrdinalIgnoreCase))
            {
                rusToEng.Remove(otherRus);
            }

            rusToEng[word] = newEng;
            engToRus[newEng] = word;

            ShowSuccess(string.Format(Messages[MessageId.Edited], word, newEng));
            Console.WriteLine();
            return;
        }

        ShowError(string.Format(Messages[MessageId.EditNotFound], word));
        Console.WriteLine();
    }

    private static void PrintList(Dictionary<string, string> engToRus)
    {
        if (engToRus.Count == 0)
        {
            ShowWarning(Messages[MessageId.ListEmpty]);
            Console.WriteLine();
            return;
        }

        ShowHeader(Messages[MessageId.Border]);
        ShowHeader(Messages[MessageId.ListTitle]);
        ShowHeader(Messages[MessageId.Border]);

        foreach (var pair in engToRus)
        {
            Console.WriteLine($"{pair.Key} → {pair.Value}");
        }

        Console.WriteLine();
    }

    private static void PrintHeader()
    {
        ShowHeader(Messages[MessageId.Border]);
        ShowHeader(Messages[MessageId.Header]);
        ShowHeader(Messages[MessageId.Border]);
        Console.WriteLine();
    }

    private static void Display(string message, ConsoleColor color)
    {
        Console.ForegroundColor = color;
        Console.WriteLine(message);
        Console.ResetColor();
    }

    private static void ShowHeader(string message) => Display(message, ConsoleColor.Cyan);
    private static void ShowSuccess(string message) => Display("✔ " + message, ConsoleColor.Green);
    private static void ShowError(string message) => Display("✘ " + message, ConsoleColor.Red);
    private static void ShowWarning(string message) => Display("! " + message, ConsoleColor.Yellow);
    private static void ShowInfo(string message) => Display(message, ConsoleColor.Cyan);
}