// Copyright (C) 2015 The Android Open Source Project
//
// This software is licensed under the terms of the GNU General Public
// License version 2, as published by the Free Software Foundation, and
// may be copied, distributed, and modified under those terms.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

#include "android/gps/KmlParser.h"
#include "android/base/testing/TestTempDir.h"

#include "android/base/testing/Utils.h"

#include <fstream>
#include <gtest/gtest.h>

using android::base::TestTempDir;

namespace android_gps {

TEST(KmlParser, ParseNonexistentFile) {
    GpsFixArray locations;
    std::string error;
    ASSERT_FALSE(KmlParser::parseFile("", &locations, &error));
    ASSERT_EQ(0, locations.size());
    EXPECT_EQ(std::string("KML document not parsed successfully."), error);
}

TEST(KmlParser, ParseEmptyFile) {
    {
        TestTempDir myDir("parse_location_tests");
        ASSERT_TRUE(myDir.path()); // NULL if error during creation.
        std::string path = myDir.makeSubPath("test.kml");

        std::ofstream myfile;
        myfile.open(path.c_str());
        myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
             "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
             "</kml>";
        myfile.close();

        GpsFixArray locations;
        std::string error;
        ASSERT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
        EXPECT_EQ(0, locations.size());
        EXPECT_EQ("", error);
     }   // destructor removes temp directory and all files under it.
}

TEST(KmlParser, ParseValidFile) {
    {
        TestTempDir myDir("parse_location_tests");
        ASSERT_TRUE(myDir.path()); // NULL if error during creation.
        std::string path = myDir.makeSubPath("test.kml");

        std::ofstream myfile;
        myfile.open(path.c_str());
        myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
         "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
             "<Placemark>"
                 "<name>Simple placemark</name>"
                 "<description>Attached to the ground.</description>"
                 "<Point>"
                 "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
                 "</Point>"
             "</Placemark>"
         "</kml>";
        myfile.close();

        GpsFixArray locations;
        std::string error;
        ASSERT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
        EXPECT_EQ(1, locations.size());
        EXPECT_EQ("", error);
     }   // destructor removes temp directory and all files under it.
}

TEST(KmlParser, ParseValidComplexFile) {
    {
        TestTempDir myDir("parse_location_tests");
        ASSERT_TRUE(myDir.path()); // NULL if error during creation.
        std::string path = myDir.makeSubPath("test.kml");

        std::ofstream myfile;
        myfile.open(path.c_str());
        myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
         "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
         "<Document>"
             "<name>KML Samples</name>"
             "<Style id=\"globeIcon\">"
             "<IconStyle></IconStyle><LineStyle><width>2</width></LineStyle>"
             "</Style>"
             "<Folder>"
                 "<name>Placemarks</name>"
                 "<description>These are just some</description>"
                 "<LookAt>"
                 "<tilt>40.5575073395506</tilt><range>500.6566641072245</range>"
                 "</LookAt>"
                 "<Placemark>"
                     "<name>Tessellated</name>"
                     "<visibility>0</visibility>"
                     "<description>Black line (10 pixels wide), height tracks terrain</description>"
                     "<LookAt><longitude>-122.0839597145766</longitude></LookAt>"
                     "<styleUrl>#downArrowIcon</styleUrl>"
                     "<Point>"
                         "<altitudeMode>relativeToGround</altitudeMode>"
                         "<coordinates>-122.084075,37.4220033612141,50</coordinates>"
                     "</Point>"
                 "</Placemark>"
                 "<Placemark>"
                     "<name>Transparent</name>"
                     "<visibility>0</visibility>"
                     "<styleUrl>#transRedPoly</styleUrl>"
                     "<Polygon>"
                         "<extrude>1</extrude>"
                         "<altitudeMode>relativeToGround</altitudeMode>"
                         "<outerBoundaryIs>"
                         "<LinearRing>"
                         "<coordinates> -122.084075,37.4220033612141,50</coordinates>"
                         "</LinearRing>"
                         "</outerBoundaryIs>"
                     "</Polygon>"
                 "</Placemark>"
             "</Folder>"
             "<Placemark>"
                 "<name>Fruity</name>"
                 "<visibility>0</visibility>"
                 "<description><![CDATA[If the <tessellate> tag has a value of n]]></description>"
                 "<LookAt><longitude>-112.0822680013139</longitude></LookAt>"
                 "<LineString>"
                     "<tessellate>1</tessellate>"
                     "<coordinates> -122.084075,37.4220033612141,50 </coordinates>"
                 "</LineString>"
             "</Placemark>"
         "</Document>"
         "</kml>";
        myfile.close();

        GpsFixArray locations;
        std::string error;
        ASSERT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
        EXPECT_EQ("", error);
        EXPECT_EQ(3, locations.size());

        EXPECT_EQ("Tessellated", locations[0].name);
        EXPECT_EQ("Black line (10 pixels wide), height tracks terrain", locations[0].description);
        EXPECT_EQ("Transparent", locations[1].name);
        EXPECT_EQ("", locations[1].description);
        EXPECT_EQ("Fruity", locations[2].name);
        EXPECT_EQ("If the <tessellate> tag has a value of n", locations[2].description);

        for (unsigned i = 0; i < locations.size(); ++i) {
            EXPECT_FLOAT_EQ(-122.084075, locations[i].longitude);
            EXPECT_FLOAT_EQ(37.4220033612141, locations[i].latitude);
            EXPECT_FLOAT_EQ(50, locations[i].elevation);
        }
    }   // destructor removes temp directory and all files under it.
}

TEST(KmlParser, ParseOneCoordinate) {
        TestTempDir myDir("parse_location_tests");
        ASSERT_TRUE(myDir.path()); // NULL if error during creation.
        std::string path = myDir.makeSubPath("test.kml");

        std::ofstream myfile;
        myfile.open(path.c_str());
        myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Placemark>"
                    "<Point>"
                    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
                    "</Point>"
                "</Placemark>"
            "</kml>";
        myfile.close();

        GpsFixArray locations;
        std::string error;

        ASSERT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
        EXPECT_EQ("", error);
        EXPECT_EQ(1, locations.size());
        EXPECT_FLOAT_EQ(-122.0822035425683, locations[0].longitude);
        EXPECT_FLOAT_EQ(37.42228990140251, locations[0].latitude);
        EXPECT_FLOAT_EQ(0.0, locations[0].elevation);
}

TEST(KmlParser, ParseMultipleCoordinates) {
        TestTempDir myDir("parse_location_tests");
        ASSERT_TRUE(myDir.path()); // NULL if error during creation.
        std::string path = myDir.makeSubPath("test.kml");

        std::ofstream myfile;
        myfile.open(path.c_str());
        myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Placemark>"
                    "<LineString>"
                    "<coordinates>-122.0822035425683,37.42228990140251,0 \
                    10.4,39.,20\t\t0,21.4,1"
                    "</coordinates>"
                    "</LineString>"
            "</Placemark>"
            "</kml>";;
        myfile.close();

        GpsFixArray locations;
        std::string error;

        ASSERT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
        EXPECT_EQ("", error);
        ASSERT_EQ(3, locations.size());

        EXPECT_FLOAT_EQ(-122.0822035425683, locations[0].longitude);
        EXPECT_FLOAT_EQ(37.42228990140251, locations[0].latitude);
        EXPECT_FLOAT_EQ(0, locations[0].elevation);
        EXPECT_FLOAT_EQ(10.4, locations[1].longitude);
        EXPECT_FLOAT_EQ(39., locations[1].latitude);
        EXPECT_FLOAT_EQ(20, locations[1].elevation);
        EXPECT_FLOAT_EQ(0, locations[2].longitude);
        EXPECT_FLOAT_EQ(21.4, locations[2].latitude);
        EXPECT_FLOAT_EQ(1, locations[2].elevation);
}

TEST(KmlParser, ParseBadCoordinates) {
    TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    // Invalid because of internal spaces.
    myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Placemark>"
                    "<LineString>"
                    "<coordinates>-122.0822035425683, 37.42228990140251, 0 \
                    10.4,39.20\t021.41"
                    "</coordinates>"
                    "</LineString>"
            "</Placemark>"
            "</kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;

    ASSERT_FALSE(KmlParser::parseFile(path.c_str(), &locations, &error));
}

TEST(KmlParser, ParseLocationNormal) {
    TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Placemark>"
                    "<name>Simple placemark</name>"
                    "<description>Attached to the ground.</description>"
                    "<Point>"
                    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
                    "</Point>"
            "</Placemark>"
            "</kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;

    ASSERT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));

    for (unsigned i = 0; i < locations.size(); ++i) {
        EXPECT_EQ("Simple placemark", locations[i].name);
        EXPECT_EQ("Attached to the ground.", locations[i].description);
        EXPECT_FLOAT_EQ(-122.0822035425683, locations[i].longitude);
        EXPECT_FLOAT_EQ(37.42228990140251, locations[i].latitude);
        EXPECT_FLOAT_EQ(0, locations[i].elevation);
    }
}

TEST(KmlParser, ParseLocationNormalMissingOptionalFields) {
    TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Placemark>"
                    "<Point>"
                    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
                    "</Point>"
            "</Placemark>"
            "</kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;

    ASSERT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
    EXPECT_EQ("", error);
    ASSERT_EQ(1, locations.size());

    for (unsigned i = 0; i < locations.size(); ++i) {
        EXPECT_EQ("", locations[i].name);
        EXPECT_EQ("", locations[i].description);
        EXPECT_FLOAT_EQ(-122.0822035425683, locations[i].longitude);
        EXPECT_FLOAT_EQ(37.42228990140251, locations[i].latitude);
        EXPECT_FLOAT_EQ(0, locations[i].elevation);
    }
}

TEST(KmlParser, ParseLocationMissingRequiredFields) {
    TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Placemark>"
                    "<name>Simple placemark</name>"
                    "<description>Attached to the ground.</description>"
            "</Placemark>"
            "</kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;

    ASSERT_FALSE(KmlParser::parseFile(path.c_str(), &locations, &error));
    EXPECT_EQ("Location found with missing or malformed coordinates", error);
}

TEST(KmlParser, ParseLocationNameOnlyFirst) {
    TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Placemark>"
                    "<name>Simple placemark</name>"
                    "<description>Attached to the ground.</description>"
                    "<LineString>"
                    "<coordinates>-122.0822035425683,37.42228990140251,0\
                    -122.0822035425683,37.42228990140251,0</coordinates>"
                    "</LineString>"
            "</Placemark>"
            "</kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;
    EXPECT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
    EXPECT_EQ("", error);
    ASSERT_EQ(2, locations.size());

    EXPECT_EQ("Simple placemark", locations[0].name);
    EXPECT_EQ("Attached to the ground.", locations[0].description);
    EXPECT_EQ("", locations[1].name);
    EXPECT_EQ("", locations[1].description);

    for (unsigned i = 0; i < locations.size(); ++i) {
        EXPECT_FLOAT_EQ(-122.0822035425683, locations[i].longitude);
        EXPECT_FLOAT_EQ(37.42228990140251, locations[i].latitude);
        EXPECT_FLOAT_EQ(0, locations[i].elevation);
    }
}

TEST(KmlParser, ParseMultipleLocations) {
     TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Placemark>"
                    "<name>Simple placemark</name>"
                    "<description>Attached to the ground.</description>"
                    "<Point>"
                    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
                    "</Point>"
            "</Placemark>"
            "<Placemark>"
                    "<name>Simple placemark</name>"
                    "<description>Attached to the ground.</description>"
                    "<Point>"
                    "<coordinates>-122.0822035425683,37.42228990140251,0\
                    -122.0822035425683,37.42228990140251,0</coordinates>"
                    "</Point>"
            "</Placemark>"
            "<Placemark>"
                    "<name>Simple placemark</name>"
                    "<description>Attached to the ground.</description>"
                    "<Point>"
                    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
                    "</Point>"
            "</Placemark>"
            "</kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;
    EXPECT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
    EXPECT_EQ("", error);
    ASSERT_EQ(4, locations.size());

    for (unsigned i = 0; i < locations.size(); ++i) {
        if (i != 2) {
            EXPECT_EQ("Simple placemark", locations[i].name);
            EXPECT_EQ("Attached to the ground.", locations[i].description);
        } else {
            EXPECT_EQ("", locations[i].name);
            EXPECT_EQ("", locations[i].description);
        }
        EXPECT_FLOAT_EQ(-122.0822035425683, locations[i].longitude);
        EXPECT_FLOAT_EQ(37.42228990140251, locations[i].latitude);
        EXPECT_FLOAT_EQ(0, locations[i].elevation);
    }
}

TEST(KmlParser, TraverseEmptyDoc) {
    TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
        "<kml xmlns=\"http://earth.google.com/kml/2.x\"></kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;
    EXPECT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
    EXPECT_EQ("", error);
    EXPECT_EQ(0, locations.size());
}

TEST(KmlParser, TraverseDocNoPlacemarks) {
    TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
        "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
        "<LineString></LineString>"
        "<name></name>"
        "</kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;
    EXPECT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
    EXPECT_EQ("", error);
    EXPECT_EQ(0, locations.size());
}

TEST(KmlParser, TraverseNestedDoc) {
    TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Document>"
            "<Folder>"
                    "<name>Placemarks</name>"
                    "<description>These are just some of the different kinds of placemarks with"
                    "which you can mark your favorite places</description>"
                    "<LookAt>"
                            "<longitude>-122.0839597145766</longitude>"
                            "<latitude>37.42222904525232</latitude>"
                            "<altitude>0</altitude>"
                            "<heading>-148.4122922628044</heading>"
                            "<tilt>40.5575073395506</tilt>"
                            "<range>500.6566641072245</range>"
                    "</LookAt>"
                    "<Placemark>"
                            "<name>Simple placemark</name>"
                            "<description>Attached to the ground.</description>"
                            "<Point>"
                            "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
                            "</Point>"
                    "</Placemark>"
            "</Folder>"
            "</Document>"
            "</kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;
    EXPECT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
    EXPECT_EQ("", error);
    ASSERT_EQ(1, locations.size());

    EXPECT_EQ("Simple placemark", locations[0].name);
    EXPECT_EQ("Attached to the ground.", locations[0].description);
    EXPECT_FLOAT_EQ(-122.0822035425683, locations[0].longitude);
    EXPECT_FLOAT_EQ(37.42228990140251, locations[0].latitude);
    EXPECT_FLOAT_EQ(0, locations[0].elevation);
}

TEST(KmlParser, ParsePlacemarkNullNameNoCrash) {
    TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    myfile <<
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Placemark>"
            "<name/>"
            "<description/>"
            "<Point>"
            "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
            "</Point>"
            "</Placemark>"
            "</kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;
    EXPECT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));
    ASSERT_EQ(1, locations.size());
    EXPECT_STREQ("", locations.front().name.c_str());
    EXPECT_STREQ("", locations.front().description.c_str());
}

TEST(KmlParser, ParseLocationNormalCommaLocale) {
    auto scopedCommaLocale = setScopedCommaLocale();

    TestTempDir myDir("parse_location_tests");
    ASSERT_TRUE(myDir.path()); // NULL if error during creation.
    std::string path = myDir.makeSubPath("test.kml");

    std::ofstream myfile;
    myfile.open(path.c_str());
    myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
            "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
            "<Placemark>"
                    "<name>Simple placemark</name>"
                    "<description>Attached to the ground.</description>"
                    "<Point>"
                    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
                    "</Point>"
            "</Placemark>"
            "</kml>";
    myfile.close();

    GpsFixArray locations;
    std::string error;

    ASSERT_TRUE(KmlParser::parseFile(path.c_str(), &locations, &error));

    for (unsigned i = 0; i < locations.size(); ++i) {
        EXPECT_EQ("Simple placemark", locations[i].name);
        EXPECT_EQ("Attached to the ground.", locations[i].description);
        EXPECT_FLOAT_EQ(-122.0822035425683, locations[i].longitude);
        EXPECT_FLOAT_EQ(37.42228990140251, locations[i].latitude);
        EXPECT_FLOAT_EQ(0, locations[i].elevation);
    }
}
}