/*
 * Copyright (C) 2018-2020 HERE Europe B.V.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */


#include "catch2/catch.hpp"

#include <iostream>
#include <string>
//#include <sstream>
//#include <type_traits>
//#include "movetk/io/csv/csv.h"
#include "movetk/TuplePrinter.h"
#include "movetk/ProbeTraits.h"
#include "movetk/Splitter.h"
#include "movetk/SplitByField.h"
#include "movetk/SplitByDifferenceThreshold.h"
#include "movetk/SplitByDistanceThreshold.h"
#include "movetk/utils/HereProbeTraits.h"
#include "movetk/geo/geo.h"


TEST_CASE( "Splitter", "[splitter]" ) {

    here::c2d::raw::ProbeParseDate d0;
    std::istringstream is0("2018-09-18 00:58:02");
    is0 >> d0;
    here::c2d::raw::ProbeParseDate d1;
    std::istringstream is1("2018-09-18 00:58:12");
    is1 >> d1;
    here::c2d::raw::ProbeParseDate d2;
    std::istringstream is2("2018-09-18 00:58:22");
    is2 >> d2;
    here::c2d::raw::ProbeParseDate d3;
    std::istringstream is3("2018-09-18 00:58:42");
    is3 >> d3;
    here::c2d::raw::ProbeParseDate d4;
    std::istringstream is4("2018-09-18 00:58:52");
    is4 >> d4;
    here::c2d::raw::ProbeParseDate d5;
    std::istringstream is5("2018-09-18 00:58:57");
    is5 >> d5;

    using Row = std::tuple<std::string, std::string, int, float, here::c2d::raw::ProbeParseDate, float>;
    Row row0 {"abc", "def", 5, 1.2, d0, 50.2};
    Row row1 {"aaa", "jkl", 4, 2.5, d1, 50.3};
    Row row2 {"aaa", "bbb", 3, 3.4, d2, 50.4};
    Row row3 {"ddd", "ttt", 2, 4.3, d3, 50.5};
    Row row4 {"eee", "vvv", 1, 5.4, d4, 50.6};
    Row row5 {"eee", "vvv", 0, 6.6, d5, 50.7};

    std::array<Row, 6> probe_points = {row0, row1, row2, row3, row4, row5};

    SECTION( "Split by field" ) {
        std::array<std::string, 6> expected_field_values = {"abc", "aaa", "ddd", "eee"};
        std::array<std::size_t, 6> expected_split_size = {1, 2, 1, 2};
        int expected_split_count = 4;

        using SplitByField0 = SplitByField<0, Row>;
        using ProbeInputIterator = decltype(probe_points.begin());
        Splitter<SplitByField0, ProbeInputIterator> splitter(probe_points.begin(), probe_points.end());

        int i = 0;
        for (const auto& rows : splitter) {
            std::cout << "Rows for split " << i << '\n';
            for (const auto& row: rows) {
                print_tuple(std::cout, row);
                std::cout << '\n';
            }
            REQUIRE( std::get<0>(rows[0]) == expected_field_values[i] );
            REQUIRE( rows.size() == expected_split_size[i] );
            i++;
        }
        REQUIRE( i == expected_split_count );
    }

    SECTION( "Split by difference threshold" ) {
        std::array<std::string, 6> expected_field_values = {"abc", "aaa", "eee", "eee"};
        std::array<std::size_t, 6> expected_split_size = {1, 3, 1, 1};
        int expected_split_count = 4;

        using SplitByDiff3 = SplitByDifferenceThreshold<3, Row>;
        SplitByDiff3 split_by_diff3(1.0);
        using ProbeInputIterator = decltype(probe_points.begin());
        Splitter<SplitByDiff3, ProbeInputIterator> splitter(probe_points.begin(), probe_points.end(), split_by_diff3);

        int i = 0;
        for (const auto& rows : splitter) {
            std::cout << "Rows for split " << i << '\n';
            for (const auto& row: rows) {
                print_tuple(std::cout, row);
                std::cout << '\n';
            }
            REQUIRE( std::get<0>(rows[0]) == expected_field_values[i] );
            REQUIRE( rows.size() == expected_split_size[i] );
            i++;
        }
        REQUIRE( i == expected_split_count );
    }

    SECTION( "Split by time difference threshold" ) {
        std::array<std::string, 6> expected_field_values = {"abc", "ddd"};
        std::array<std::size_t, 6> expected_split_size = {3, 3};
        int expected_split_count = 2;

        using SplitByDiff = SplitByDifferenceThreshold<4, Row>;
        SplitByDiff split_by_diff(15.0);
        using ProbeInputIterator = decltype(probe_points.begin());
        Splitter<SplitByDiff, ProbeInputIterator> splitter(probe_points.begin(), probe_points.end(), split_by_diff);

        int i = 0;
        for (const auto& rows : splitter) {
            std::cout << "Rows for split " << i << '\n';
            for (const auto& row: rows) {
                print_tuple(std::cout, row);
                std::cout << '\n';
            }
            REQUIRE( std::get<0>(rows[0]) == expected_field_values[i] );
            REQUIRE( rows.size() == expected_split_size[i] );
            i++;
        }
        REQUIRE( i == expected_split_count );
    }

    SECTION( "Split by distance threshold" ) {
//        std::array<std::string, 6> expected_field_values = {"abc", "ddd"};
//        std::array<std::size_t, 6> expected_split_size = {3, 3};
//        int expected_split_count = 2;

        using SplitByDist = SplitByDistanceThreshold<3, 5, Row>;
        std::function<double(float, float, float, float)> distancefn = distance_exact;
        SplitByDist split_by_dist(110000.0, distancefn);
        using ProbeInputIterator = decltype(probe_points.begin());
        Splitter<SplitByDist, ProbeInputIterator> splitter(probe_points.begin(), probe_points.end(), split_by_dist);

        int i = 0;
        for (const auto& rows : splitter) {
            std::cout << "Rows for split " << i << '\n';
            for (const auto& row: rows) {
                print_tuple(std::cout, row);
                std::cout << '\n';
            }
//            REQUIRE( std::get<0>(rows[0]) == expected_field_values[i] );
//            REQUIRE( rows.size() == expected_split_size[i] );
            i++;
        }
//        REQUIRE( i == expected_split_count );
    }

//    SECTION( "Line without new line is not read" ) {
//
//    }
}