main.cpp

#include "main.h"

using namespace std;

int main(int argc, char *argv[])
{
    QSet<Error> errors;
    bool hasErrors = false;

    QCoreApplication a(argc, argv);
    QCoreApplication::setApplicationName("reverse_translit");
    QCoreApplication::setApplicationVersion("1.0");

    setlocale(LC_ALL, "");

    // Синтаксический анализатор параметров командной строки
    QCommandLineParser parser;
    parser.setApplicationDescription("Reverse translit (from latin to russian)");
    parser.addHelpOption();
    parser.addVersionOption();
    parser.addPositionalArgument("input", "Input file");
    parser.addPositionalArgument("accordance", "Accordance file");
    parser.addPositionalArgument("output", "Output file");
    parser.process(a);

    const QStringList args = parser.positionalArguments();

    // Проверка на кол-во переданных аргументов
    if (!validateArgumentsNumber(args, errors))
    {
        std::cout << errors.values().first().toString().toStdString() << std::endl;
        return 0;
    }

    // Получить пути к файлам
    QString inputPath = args[0];
    QString accordancePath = args[1];
    QString outputPath = args[2];

    // Получить файлы
    QFile inputFile(inputPath);
    QFile accordanceFile(accordancePath);
    QFile outputFile(outputPath);

    // Проверка путей к файлам и разрешений
    if (!inputFile.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        errors.insert(Error(Error::FileNotFound));
        hasErrors = true;
    }

    if (!accordanceFile.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        errors.insert(Error(Error::FileNotFound));
        hasErrors = true;
    }

    if (!outputFile.open(QIODevice::WriteOnly))
    {
        errors.insert(Error(Error::OutputFileInvalid));
        hasErrors = true;
    }

    // Прочитать, проверив файл соответствий и сформировать объект-соответствий
    QMap<QString, QString> accordances;
    while(!accordanceFile.atEnd())
    {
        QString line = accordanceFile.readLine().trimmed();

        if (!validateAndInsertAccordance(line, accordances, errors))
            hasErrors = true;
    }

    if (accordances.isEmpty())
    {
        errors.insert(Error(Error::AccordanceEmpty));
        hasErrors = true;
    }

    // Чтение и проверка входного текста
    QString inputText = inputFile.readAll();
    if (!validateInputText(inputText, errors))
    {
        hasErrors = true;
    }

    if (hasErrors)
    {
        for (const Error& e : errors) {
            std::cout << e.toString().toStdString() << std::endl;
        }
        return 0;
    }

    // Трналитирировать текст
    Transliterator transliterator(inputText);
    transliterator.transliterate(accordances);
    QString outputText = transliterator.toString();

    std::cout << outputText.toStdString() << std::endl;

    // Записать транлитирированный текст в выходной файл
    QTextStream outStream(&outputFile);
    outStream << outputText;
}


bool validateArgumentsNumber(const QStringList& args, QSet<Error>& errors)
{
    switch (args.count()) {
    case 0:
        errors.insert(Error(Error::MissingInputFile));
        return false;
    case 1:
        errors.insert(Error(Error::MissingAccordanceFile));
        return false;
    case 2:
        errors.insert(Error(Error::MissingOutputFile));
        return false;
    default:
        if (args.count() > 3) {
            errors.insert(Error(Error::TooManyArguments));
            return false;
        }
    }
    return true;
}


bool validateAndInsertAccordance(const QString& line, QMap<QString, QString>& accordances, QSet<Error>& errors)
{
    if (line.isEmpty()) {
        errors.insert(Error(Error::AccordanceEmpty));
        return false;
    }

    QStringList parts = line.split(u':');
    if (parts.size() != 2) {
        errors.insert(Error(Error::AccordanceMissingColon, line));
        return false;
    }

    QString left = parts.at(0).trimmed();
    QString right = parts.at(1).trimmed();

    if (left.isEmpty()) {
        errors.insert(Error(Error::AccordanceMissingLeft, right));
        return false;
    }

    if (right.isEmpty()) {
        errors.insert(Error(Error::AccordanceMissingRight, left));
        return false;
    }

    QRegularExpression notRussian("[^А-Яа-я]+");
    QRegularExpression notLatin("[^A-Za-z]+");

    if (left.contains(notRussian)) {
        errors.insert(Error(Error::AccordanceInvalidRussian, left));
        return false;
    }

    if (right.contains(notLatin)) {
        errors.insert(Error(Error::AccordanceInvalidLatin, right));
        return false;
    }

    if (accordances.contains(left)) {
        errors.insert(Error(Error::AccordanceDuplicate, left));
        return false;
    }

    accordances.insert(left.toLower(), right.toLower());
    return true;
}


bool validateInputText(QString inputText, QSet<Error>& errors)
{
    if (inputText.isEmpty()) {
        errors.insert(Error(Error::InputTextEmpty));
        return false;
    }

    QRegularExpressionMatch match;
    if (inputText.contains(QRegularExpression("[А-Яа-я]+"), &match)) {
        errors.insert(Error(Error::InvalidCharInInput, match.capturedTexts().first()));
        return false;
    }

    return true;
}