#include "mremoteng_importer.h"

#include "test_mremoteng_importer_fixtures.h"

#include <QTest>

#include <algorithm>

class TestMRemoteNGImporter : public QObject
{
    Q_OBJECT

private slots:
    void parsesFoldersAndProfilesFromRealisticSample();
    void mapsRdpConnectionFieldsCorrectly();
    void mapsSshConnectionFieldsCorrectly();
    void skipsUnsupportedProtocolWithoutDroppingSilently();
    void neverImportsPasswordField();
    void refusesFullFileEncryptedExports();
    void refusesUnrecognizedRootElement();
    void refusesMalformedXml();
    void refusesEmptyInput();
};

void TestMRemoteNGImporter::parsesFoldersAndProfilesFromRealisticSample()
{
    const MRemoteNGImportResult result = parseMRemoteNGConnections(QByteArray(mRemoteNGSampleXml()));
    QVERIFY(result.errorMessage.isEmpty());

    QCOMPARE(result.folders.size(), size_t(2));
    QCOMPARE(result.folders[0], QStringLiteral("Work"));
    QCOMPARE(result.folders[1], QStringLiteral("Work/Servers"));

    // 3 connection nodes in the sample: DC (RDP), build-box (SSH2),
    // oldkiosk (VNC, unsupported) -- only the first two should come
    // through as imported profiles.
    QCOMPARE(result.profiles.size(), size_t(2));
    QCOMPARE(result.skippedUnsupportedProtocol.size(), 1);
}

void TestMRemoteNGImporter::mapsRdpConnectionFieldsCorrectly()
{
    const MRemoteNGImportResult result = parseMRemoteNGConnections(QByteArray(mRemoteNGSampleXml()));
    const auto it = std::find_if(result.profiles.begin(), result.profiles.end(),
                                 [](const MRemoteNGImportedProfile& p) {
                                     return p.profile.name == QStringLiteral("DC");
                                 });
    QVERIFY(it != result.profiles.end());
    QCOMPARE(it->profile.host, QStringLiteral("10.0.0.5"));
    QCOMPARE(it->profile.port, 3389);
    QCOMPARE(it->profile.username, QStringLiteral("Administrator"));
    QCOMPARE(it->profile.protocol, QStringLiteral("RDP"));
    QCOMPARE(it->profile.domain, QStringLiteral("CORP"));
    QCOMPARE(it->folderPath, QStringLiteral("Work"));
}

void TestMRemoteNGImporter::mapsSshConnectionFieldsCorrectly()
{
    const MRemoteNGImportResult result = parseMRemoteNGConnections(QByteArray(mRemoteNGSampleXml()));
    const auto it = std::find_if(result.profiles.begin(), result.profiles.end(),
                                 [](const MRemoteNGImportedProfile& p) {
                                     return p.profile.name == QStringLiteral("build-box");
                                 });
    QVERIFY(it != result.profiles.end());
    QCOMPARE(it->profile.host, QStringLiteral("build.internal"));
    QCOMPARE(it->profile.port, 22);
    QCOMPARE(it->profile.username, QStringLiteral("deploy"));
    // SSH1/SSH2 both collapse to OrbitHub's single "SSH" protocol.
    QCOMPARE(it->profile.protocol, QStringLiteral("SSH"));
    QCOMPARE(it->profile.authMode, QStringLiteral("Password"));
    // Domain is RDP-only; must not leak through for SSH.
    QCOMPARE(it->profile.domain, QString());
    QCOMPARE(it->folderPath, QStringLiteral("Work/Servers"));
}

void TestMRemoteNGImporter::skipsUnsupportedProtocolWithoutDroppingSilently()
{
    const MRemoteNGImportResult result = parseMRemoteNGConnections(QByteArray(mRemoteNGSampleXml()));
    QCOMPARE(result.skippedUnsupportedProtocol.size(), 1);
    QVERIFY(result.skippedUnsupportedProtocol[0].contains(QStringLiteral("oldkiosk")));
    QVERIFY(result.skippedUnsupportedProtocol[0].contains(QStringLiteral("VNC")));
}

void TestMRemoteNGImporter::neverImportsPasswordField()
{
    // Profile has no password-storing field at all -- this test exists to
    // document that guarantee, not to probe internals that don't exist.
    const MRemoteNGImportResult result = parseMRemoteNGConnections(QByteArray(mRemoteNGSampleXml()));
    QVERIFY(!result.profiles.empty());
    for (const MRemoteNGImportedProfile& item : result.profiles) {
        QCOMPARE(item.profile.authMode, QStringLiteral("Password"));
        QVERIFY(item.profile.privateKeyPath.isEmpty());
    }
}

void TestMRemoteNGImporter::refusesFullFileEncryptedExports()
{
    const MRemoteNGImportResult result = parseMRemoteNGConnections(QByteArray(mRemoteNGFullFileEncryptedXml()));
    QVERIFY(!result.errorMessage.isEmpty());
    QVERIFY(result.errorMessage.contains(QStringLiteral("full file encryption"), Qt::CaseInsensitive));
    QVERIFY(result.profiles.empty());
}

void TestMRemoteNGImporter::refusesUnrecognizedRootElement()
{
    const MRemoteNGImportResult result = parseMRemoteNGConnections(QByteArray(mRemoteNGWrongRootXml()));
    QVERIFY(!result.errorMessage.isEmpty());
}

void TestMRemoteNGImporter::refusesMalformedXml()
{
    const MRemoteNGImportResult result =
        parseMRemoteNGConnections(QByteArray("<mrng:Connections><Node "));
    QVERIFY(!result.errorMessage.isEmpty());
}

void TestMRemoteNGImporter::refusesEmptyInput()
{
    const MRemoteNGImportResult result = parseMRemoteNGConnections(QByteArray());
    QVERIFY(!result.errorMessage.isEmpty());
}

QTEST_APPLESS_MAIN(TestMRemoteNGImporter)
#include "test_mremoteng_importer.moc"