/*****************************************************************************************
 *                                                                                       *
 * OpenSpace                                                                             *
 *                                                                                       *
 * Copyright (c) 2014-2025                                                               *
 *                                                                                       *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
 * software and associated documentation files (the "Software"), to deal in the Software *
 * without restriction, including without limitation the rights to use, copy, modify,    *
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
 * permit persons to whom the Software is furnished to do so, subject to the following   *
 * conditions:                                                                           *
 *                                                                                       *
 * The above copyright notice and this permission notice shall be included in all copies *
 * or substantial portions of the Software.                                              *
 *                                                                                       *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
 ****************************************************************************************/

#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>

#include <openspace/json.h>
#include <openspace/util/spicemanager.h>
#include <ghoul/filesystem/filesystem.h>
#include <ghoul/logging/logmanager.h>

#ifdef OPENSPACE_MODULE_SPACE_ENABLED
#include <modules/space/horizonsfile.h>
#endif // OPENSPACE_MODULE_SPACE_ENABLED

using namespace openspace;
using json = nlohmann::json;

namespace {

    // Struct to hold the data for some of the tests
    struct HorizonsTestData {
        std::string observer;
        std::string target;
        std::string start;
        std::string stop;
        std::string step;
        std::string unit;
    };

    // Avoid repetitive code by using these functions
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    void testHorizonsAnswer(const HorizonsTestData& data, HorizonsType type,
        const std::filesystem::path& filePath,
        HorizonsResultCode expectedAnswerCode)
    {
        const std::string url = constructHorizonsUrl(
            type,
            data.target,
            data.observer,
            data.start,
            data.stop,
            data.step,
            data.unit
        );
        const json answer = sendHorizonsRequest(url, filePath);
        HorizonsResultCode code = isValidHorizonsAnswer(answer);
        CHECK(code == expectedAnswerCode);

        CHECK(std::filesystem::is_regular_file(filePath));
        std::filesystem::remove(filePath);
        CHECK(!std::filesystem::is_regular_file(filePath));
    }

    void testHorizonsAnswerAndResult(const HorizonsTestData& data, HorizonsType type,
        const std::filesystem::path& filePath,
        HorizonsResultCode expectedAnswerCode,
        HorizonsResultCode expectedResultCode,
        bool shouldDeleteFile = true)
    {
        const std::string url = constructHorizonsUrl(
            type,
            data.target,
            data.observer,
            data.start,
            data.stop,
            data.step,
            data.unit
        );
        json answer = sendHorizonsRequest(url, filePath);
        HorizonsResultCode answerCode = isValidHorizonsAnswer(answer);
        CHECK(answerCode == expectedAnswerCode);

        // Extract the result from the json object and test it
        auto result = answer.find("result");
        CHECK(result != answer.end());

        const HorizonsFile horizonsFile(filePath, result->get<std::string>());
        HorizonsResultCode resultCode = isValidHorizonsFile(horizonsFile.file());
        CHECK(resultCode == expectedResultCode);

        CHECK(std::filesystem::is_regular_file(filePath));
        if (shouldDeleteFile) {
            std::filesystem::remove(filePath);
            CHECK(!std::filesystem::is_regular_file(filePath));
        }
    }

    void testReadingHorizons(HorizonsType type, const std::filesystem::path& filePath,
                             double t0, double x0, double y0, double z0, double t1,
                             double x1, double y1, double z1, double t2, double x2,
                             double y2, double z2)
    {
        // Get files and make sure they exist
        const std::filesystem::path kernel =
            absPath("${TESTDIR}/horizonsTest/naif0012.tls");
        CHECK(std::filesystem::is_regular_file(kernel));
        CHECK(std::filesystem::is_regular_file(filePath));

        // Initialize SpiceManager and load leap second kernel
        SpiceManager::initialize();
        openspace::SpiceManager::ref().loadKernel(kernel);

        // Read the file
        HorizonsResult result = readHorizonsFile(filePath);

        // Check the result
        CHECK(result.type == type);
        CHECK(result.errorCode == HorizonsResultCode::Valid);

        std::vector<HorizonsKeyframe> data = result.data;
        REQUIRE(data.size() == 3);

        CHECK(data[0].time == Catch::Approx(t0));
        CHECK(data[0].position.x == Catch::Approx(x0));
        CHECK(data[0].position.y == Catch::Approx(y0));
        CHECK(data[0].position.z == Catch::Approx(z0));


        CHECK(data[1].time == Catch::Approx(t1));
        CHECK(data[1].position.x == Catch::Approx(x1));
        CHECK(data[1].position.y == Catch::Approx(y1));
        CHECK(data[1].position.z == Catch::Approx(z1));


        CHECK(data[2].time == Catch::Approx(t2));
        CHECK(data[2].position.x == Catch::Approx(x2));
        CHECK(data[2].position.y == Catch::Approx(y2));
        CHECK(data[2].position.z == Catch::Approx(z2));

        // Clean up
        openspace::SpiceManager::ref().unloadKernel(kernel);
        openspace::SpiceManager::deinitialize();
    }
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

// Test if the space module is enable or not
TEST_CASE("HorizonsFile: Space module", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    CHECK(true);
    LINFOC("test_horizons", "Downloading Horizons test data ...");
#else
    LERRORC("test_horizons", "These tests requires the Space module to be enabled");
    CHECK(false);
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

// Test Horizons requests and error handling
// Test the errors that are captured by the error field in the json result
TEST_CASE("HorizonsFile: File size too large", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "@ssb";
    data.target = "-74"; // MRO
    data.start = "2005-08-13 00:00:00";
    data.stop = "2022-07-01 00:00:00";
    data.step = "1";
    data.unit = "m";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_1.hrz"
    );
    const HorizonsResultCode expectedAnswerCode = HorizonsResultCode::ErrorSize;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswer(data, type, filePath, expectedAnswerCode);

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswer(data, type, filePath, expectedAnswerCode);
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Time steps too large", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "@ssb";
    data.target = "-74"; // MRO
    data.start = "2005-08-13 00:00:00";
    data.stop = "2022-07-01 00:00:00";
    data.step = "1111111111";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_2.hrz"
    );
    const HorizonsResultCode expectedAnswerCode = HorizonsResultCode::ErrorSpan;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswer(data, type, filePath, expectedAnswerCode);

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswer(data,type, filePath, expectedAnswerCode);
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Outside available time range", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "@ssb";
    data.target = "Tesla";
    data.start = "1950-05-19 00:00:00";
    data.stop = "2000-05-19 00:00:00";
    data.step = "1";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_3.hrz"
    );
    const HorizonsResultCode expectedAnswerCode = HorizonsResultCode::ErrorTimeRange;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswer(data, type, filePath, expectedAnswerCode);

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswer(data, type, filePath, expectedAnswerCode);
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: No observer", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "abcdefghijkl";
    data.target = "Tesla";
    data.start = "2021-05-19 00:00:00";
    data.stop = "2022-05-19 00:00:00";
    data.step = "1";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_4.hrz"
    );
    const HorizonsResultCode answer = HorizonsResultCode::ErrorNoObserver;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswer(data, type, filePath, answer);

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswer(data, type, filePath, answer);
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Observer and target same", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "500@4"; // Mars barycenter
    data.target = "4";       // Mars barycenter
    data.start = "2021-05-19 00:00:00";
    data.stop = "2022-05-19 00:00:00";
    data.step = "1";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_5.hrz"
    );
    const HorizonsResultCode answer = HorizonsResultCode::ErrorObserverTargetSame;

    // This test is only for Observer type format
    const HorizonsType type = HorizonsType::Observer;
    testHorizonsAnswer(data, type, filePath, answer);
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Multiple observer stations", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "l2";
    data.target = "Tesla";
    data.start = "2021-05-19 00:00:00";
    data.stop = "2022-05-19 00:00:00";
    data.step = "1";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_6.hrz"
    );
    const HorizonsResultCode answer = HorizonsResultCode::MultipleObserverStations;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswer(data, type, filePath, answer);

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswer(data, type, filePath, answer);
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}


// Test errors that are nat captured by the error field in the json result
TEST_CASE("HorizonsFile: Multiple observers", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "@mars";
    data.target = "Tesla";
    data.start = "2021-05-19 00:00:00";
    data.stop = "2022-05-19 00:00:00";
    data.step = "1";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_7.hrz"
    );
    const HorizonsResultCode expectedAnswerCode = HorizonsResultCode::Valid;
    const HorizonsResultCode expectedResultCode = HorizonsResultCode::MultipleObserver;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: No target", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "@ssb";
    data.target = "abcdefghijkl";
    data.start = "2021-05-20 00:00:00";
    data.stop = "2022-05-20 00:00:00";
    data.step = "1";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_8.hrz"
    );
    const HorizonsResultCode expectedAnswerCode = HorizonsResultCode::Valid;
    const HorizonsResultCode expectedResultCode = HorizonsResultCode::ErrorNoTarget;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Multiple targets (major bodies)", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "@ssb";
    data.target = "mars";
    data.start = "2021-05-20 00:00:00";
    data.stop = "2022-05-20 00:00:00";
    data.step = "1";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_9.hrz"
    );
    const HorizonsResultCode expectedAnswerCode = HorizonsResultCode::Valid;
    const HorizonsResultCode expectedResultCode = HorizonsResultCode::MultipleTarget;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Multiple targets (minor bodies case 1)", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "@ssb";
    data.target = "DES = 141P;";
    data.start = "2021-05-20 00:00:00";
    data.stop = "2022-05-20 00:00:00";
    data.step = "1";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_10.hrz"
    );
    const HorizonsResultCode expectedAnswerCode = HorizonsResultCode::Valid;
    const HorizonsResultCode expectedResultCode = HorizonsResultCode::MultipleTarget;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Multiple targets (minor bodies case 2)", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "@ssb";
    data.target = "borisov";
    data.start = "2021-05-20 00:00:00";
    data.stop = "2022-05-20 00:00:00";
    data.step = "1";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_11.hrz"
    );
    const HorizonsResultCode expectedAnswerCode = HorizonsResultCode::Valid;
    const HorizonsResultCode expectedResultCode = HorizonsResultCode::MultipleTarget;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Detect multiple observers or targets", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "@l2";
    data.target = "90001048"; // 141P Machholz 2 epoch 2019
    data.start = "2021-05-23 00:00:00";
    data.stop = "2022-05-23 00:00:00";
    data.step = "1";
    data.unit = "d";
    const std::filesystem::path filePath = absPath(
        "${TESTDIR}/horizonsTest/horizonstest_12.hrz"
    );
    const HorizonsResultCode expectedAnswerCode = HorizonsResultCode::Valid;
    const HorizonsResultCode expectedResultCode = HorizonsResultCode::MultipleObserver;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePath,
        expectedAnswerCode,
        expectedResultCode
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Valid request and response", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    HorizonsTestData data;
    data.observer = "@ssb";
    data.target = "Tesla";
    data.start = "2022-05-22 00:00:00";
    data.stop = "2022-05-23 00:00:00";
    data.step = "12";
    data.unit = "h";
    const std::filesystem::path filePathVector = absPath(
        "${TESTDIR}/horizonsTest/validVectorFile.hrz"
    );
    const std::filesystem::path filePathObserver = absPath(
        "${TESTDIR}/horizonsTest/validObserverFile.hrz"
    );
    const HorizonsResultCode expectedAnswerCode = HorizonsResultCode::Valid;
    const HorizonsResultCode expectedResultCode = HorizonsResultCode::Valid;

    // Test Vector format
    HorizonsType type = HorizonsType::Vector;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePathVector,
        expectedAnswerCode,
        expectedResultCode,
        false
    );

    // Test Observer format
    type = HorizonsType::Observer;
    testHorizonsAnswerAndResult(
        data,
        type,
        filePathObserver,
        expectedAnswerCode,
        expectedResultCode,
        false
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}


// Test parsing of timeranges
// Since data can get updated this is tested towards stored files
TEST_CASE("HorizonsFile: Parsing time range with time", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    const std::filesystem::path filePath =
        absPath("${TESTDIR}/horizonsTest/timerange_time.hrz");
    const HorizonsFile horizonsFile(filePath);

    // Parse time range
    const std::pair<std::string, std::string> timeRange = horizonsFile.parseValidTimeRange(
        "Trajectory files",
        "************",
        "Trajectory name"
    );

    CHECK(timeRange.first == "2005-Aug-12 T 12:42");
    CHECK(timeRange.second == "2022-Sep-02 T 02:55");
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Parsing time range without time", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    const std::filesystem::path filePath =
        absPath("${TESTDIR}/horizonsTest/timerange_no_time.hrz");
    const HorizonsFile horizonsFile(filePath);

    // Parse time range
    const std::pair<std::string, std::string> timeRange = horizonsFile.parseValidTimeRange(
        "Trajectory files",
        "************",
        "Trajectory name",
        false
    );

    CHECK(timeRange.first == "2013-Dec-19");
    CHECK(timeRange.second == "2026-Sep-14");
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}


// Test parsing of matches
// Since data can get updated this is tested towards stored files
TEST_CASE("HorizonsFile: Parsing multiple matching observers", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    const std::filesystem::path filePath =
        absPath("${TESTDIR}/horizonsTest/parse_multiple_observers.hrz");
    const HorizonsFile horizonsFile(filePath);

    // Parse matches
    const std::vector<std::string> matches =
        horizonsFile.parseMatches("Name", "matches", ">MATCH NAME<");

    REQUIRE(matches.size() == 3);
    CHECK(matches[0] ==
        "  ID#      Name                               Designation  IAU/aliases/other   "
    );
    CHECK(matches[1] ==
        "        3  Earth-Moon Barycenter                           EMB                  "
    );
    CHECK(matches[2] ==
        "      399  Earth                                           Geocenter            "
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Parsing multiple matching targets", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    const std::filesystem::path filePath =
        absPath("${TESTDIR}/horizonsTest/parse_multiple_targets.hrz");
    const HorizonsFile horizonsFile(filePath);

    // Parse matches
    const std::vector<std::string> matches =
        horizonsFile.parseMatches("Name", "matches", ">MATCH NAME<");

    REQUIRE(matches.size() == 11);
    CHECK(matches[0] ==
        "  ID#      Name                               Designation  IAU/aliases/other   "
    );
    CHECK(matches[1] ==
        "        4  Mars Barycenter                                                      "
    );
    CHECK(matches[2] ==
        "      499  Mars                                                                 "
    );
    CHECK(matches[3] ==
        "       -3  Mars Orbiter Mission (MOM) (spacec              Mangalyaan           "
    );
    CHECK(matches[4] ==
        "      -41  Mars Express (spacecraft)                       MEX                  "
    );
    CHECK(matches[5] ==
        "      -53  Mars Odyssey (spacecraft)                                            "
    );
    CHECK(matches[6] ==
        "     -530  Mars Pathfinder (spacecraft)                    MPF                  "
    );
    CHECK(matches[7] ==
        "      -74  Mars Reconnaissance Orbiter (space              MRO                  "
    );
    CHECK(matches[8] ==
        "      -76  Mars Science Laboratory (spacecraf              Curiosity MSL        "
    );
    CHECK(matches[9] ==
        "     -143  ExoMars16 TGO (spacecraft)                                           "
    );
    CHECK(matches[10] ==
        "     -168  Mars2020 (spacecraft)                           Perserverance Ingenu "
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Parsing multiple matching stations", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    const std::filesystem::path filePath =
        absPath("${TESTDIR}/horizonsTest/parse_multiple_stations.hrz");
    CHECK(std::filesystem::is_regular_file(filePath));
    const HorizonsFile horizonsFile(filePath);

    // Parse matches
    const std::vector<std::string> matches =
        horizonsFile.parseMatches("Observatory Name", "Multiple matching stations found");

    REQUIRE(matches.size() == 11);
    CHECK(matches[0] ==
        "   #   E. Lon    DXY      DZ    Observatory Name"
    );
    CHECK(matches[1] ==
        "  L20  18.3207 +308014 +293859  AG_Sarajevo Observatory, Sarajevo"
    );
    CHECK(matches[2] ==
        "  L21  27.4213 +307050 +294814  Ostrov Observatory, Constanta"
    );
    CHECK(matches[3] ==
        "  L22  27.6695 +295446 +306365  Barlad Observatory"
    );
    CHECK(matches[4] ==
        "  L23  27.8319 +299346 +302574  Schela"
    );
    CHECK(matches[5] ==
        "  L24  27.9289 +383214 -186499  Gauteng"
    );
    CHECK(matches[6] ==
        "  L25  14.4374 +255033 +340528  Smolecin"
    );
    CHECK(matches[7] ==
        "  L26  11.8102 +316937 +284229  Sanderphil Urban Obs., Civitavecchia"
    );
    CHECK(matches[8] ==
        "  L27   5.6470 +307222 +294693  29PREMOTE Obs., Dauban {Soulier]"
    );
    CHECK(matches[9] ==
        "  L28  15.4634 +323190 +277274  ISON-Castelgrande Observatory"
    );
    CHECK(matches[10] ==
        "  L29  18.0169 +391400 -168725  Drebach-South Observatory, Windhoek"
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}


// Test reading of data and compare a recent request with a stored file
TEST_CASE("HorizonsFile: Reading Vector data from request", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    const HorizonsType type = HorizonsType::Vector;
    const std::filesystem::path filePathVector =
        absPath("${TESTDIR}/horizonsTest/validVectorFile.hrz");

    const double t0 = 706449669.18513119;
    const double x0 = -126367222949.377166748;
    const double y0 = 63060654906.4096450806;
    const double z0 = -126727123841.2694549561;

    const double t1 = 706492869.18512082;
    const double x1 = -127007207301.5597076416;
    const double y1 = 62521315275.043838501;
    const double z1 = -125920644491.178314209;

    const double t2 = 706536069.18511045;
    const double x2 = -127642636109.8239135742;
    const double y2 = 61979705046.1750488281;
    const double z2 = -125109598352.4534301758;

    testReadingHorizons(
        type, filePathVector,
        t0, x0, y0, z0,
        t1, x1, y1, z1,
        t2, x2, y2, z2
    );

    // Clean up
    std::filesystem::remove(filePathVector);
    CHECK(!std::filesystem::is_regular_file(filePathVector));
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Reading Observer data from request", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    const HorizonsType type = HorizonsType::Observer;
    const std::filesystem::path filePathObserver =
        absPath("${TESTDIR}/horizonsTest/validObserverFile.hrz");

    const double t0 = 706449669.18513119;
    const double x0 = -126358694845.7201385498;
    const double y0 = 63067750258.2510452271;
    const double z0 = -126737728343.3621063232;

    const double t1 = 706492869.18512082;
    const double x1 = -126998752832.9455413818;
    const double y1 = 62528427647.3945465088;
    const double z1 = -125931292434.5601806641;

    const double t2 = 706536069.18511045;
    const double x2 = -127634254978.5487976074;
    const double y2 = 61986837622.6675033569;
    const double z2 = -125120288440.1994018555;

    testReadingHorizons(
        type, filePathObserver,
        t0, x0, y0, z0,
        t1, x1, y1, z1,
        t2, x2, y2, z2
    );

    // Clean up
    std::filesystem::remove(filePathObserver);
    CHECK(!std::filesystem::is_regular_file(filePathObserver));
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}


TEST_CASE("HorizonsFile: Reading Vector data from file", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    const HorizonsType type = HorizonsType::Vector;
    const std::filesystem::path filePathVector =
        absPath("${TESTDIR}/horizonsTest/vectorFileTest.hrz");

    const double t0 = 706449669.18513119;
    const double x0 = -126379670172.70331;
    const double y0 = 63049830070.652786;
    const double z0 = -126710964556.55870;

    const double t1 = 706492869.18512082;
    const double x1 = -127019567853.94952;
    const double y1 = 62510445746.414017;
    const double z1 = -125904395646.64995;

    const double t2 = 706536069.18511045;
    const double x2 = -127654909093.56494;
    const double y2 = 61968790989.645737;
    const double z2 = -125093260079.10854;

    testReadingHorizons(
        type, filePathVector,
        t0, x0, y0, z0,
        t1, x1, y1, z1,
        t2, x2, y2, z2
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}

TEST_CASE("HorizonsFile: Reading Observer data from file", "[horizonsfile]") {
#ifdef OPENSPACE_MODULE_SPACE_ENABLED
    const HorizonsType type = HorizonsType::Observer;
    const std::filesystem::path filePathObserver =
        absPath("${TESTDIR}/horizonsTest/observerFileTest.hrz");

    const double t0 = 706449669.18513119;
    const double x0 = -126371142157.29857;
    const double y0 = 63056923889.044579;
    const double z0 = -126721572150.18513;

    const double t1 = 706492869.18512082;
    const double x1 = -127011112787.76295;
    const double y1 = 62517559574.749786;
    const double z1 = -125915045896.36182;

    const double t2 = 706536069.18511045;
    const double x2 = -127646529740.40393;
    const double y2 = 61975921972.090714;
    const double z2 = -125103951590.60988;

    testReadingHorizons(
        type, filePathObserver,
        t0, x0, y0, z0,
        t1, x1, y1, z1,
        t2, x2, y2, z2
    );
#endif // OPENSPACE_MODULE_SPACE_ENABLED
}