#pragma once
#include "string_processing.h"
#include "document.h"
#include "log_duration.h"

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <set>
#include <map>
#include <tuple>
#include <numeric>
#include <algorithm>
#include <cmath>
#include <execution>
#include <utility>
#include <functional>

const int MAX_RESULT_DOCUMENT_COUNT = 5;
const double DELTA = 1e-6;

class SearchServer {
public:
    template <typename StringContainer>
    SearchServer(const StringContainer& stop_words);
    // Invoke delegating constructor from string container
    explicit SearchServer(const std::string& stop_words_text);
    explicit SearchServer(const std::string_view stop_words_text);

    //void AddDocument(int document_id, const std::string& document, DocumentStatus status,
    //    const std::vector<int>& ratings);
    void AddDocument(int document_id, const std::string_view document, DocumentStatus status,
        const std::vector<int>& ratings);

    template <typename DocumentPredicate>
    std::vector<Document> FindTopDocuments(const std::string_view raw_query, DocumentPredicate document_predicate) const;
    std::vector<Document> FindTopDocuments(const std::string_view raw_query, DocumentStatus status) const;
    std::vector<Document> FindTopDocuments(const std::string_view raw_query) const;
    //std::vector<Document> FindTopDocuments(const std::string& raw_query, DocumentPredicate document_predicate) const;
    //std::vector<Document> FindTopDocuments(const std::string& raw_query, DocumentStatus status) const;
    //std::vector<Document> FindTopDocuments(const std::string& raw_query) const;

    // Поиск интересующих слов в конкретном документе
    std::tuple<std::vector<std::string_view>, DocumentStatus> MatchDocument(const std::string_view raw_query,
        int document_id) const;
    std::tuple<std::vector<std::string_view>, DocumentStatus> MatchDocument(std::execution::sequenced_policy,
        const std::string_view raw_query, int document_id) const;
    std::tuple<std::vector<std::string_view>, DocumentStatus> MatchDocument(std::execution::parallel_policy,
        const std::string_view raw_query, int document_id) const;
    //std::tuple<std::vector<std::string>, DocumentStatus> MatchDocument(const std::string& raw_query,
    //    int document_id) const;
    //std::tuple<std::vector<std::string>, DocumentStatus> MatchDocument(std::execution::sequenced_policy,
    //    const std::string& raw_query, int document_id) const;
    //std::tuple<std::vector<std::string>, DocumentStatus> MatchDocument(std::execution::parallel_policy,
    //    const std::string& raw_query, int document_id) const;

    int GetDocumentCount() const;
    const std::map<std::string_view, double>& GetWordFrequencies(int document_id) const;
    //const std::map<std::string, double>& GetWordFrequencies(int document_id) const;
    void RemoveDocument(int document_id);
    void RemoveDocument(std::execution::sequenced_policy, int document_id);
    void RemoveDocument(std::execution::parallel_policy, int document_id);

    std::set<int>::const_iterator begin();
    std::set<int>::const_iterator end();

private:
    std::set<int> order_addition_document_;
    struct DocumentData {
        int rating;
        DocumentStatus status;
    };
    const std::set<std::string, std::less<>> stop_words_;
    // частота слова в каждом документе
    std::map<std::string_view, std::map<int, double>> word_to_document_freqs_;
    std::map<int, DocumentData> documents_;
    // частоты каждого слова в документе
    std::map<int, std::map<std::string, double, std::less<>>> word_frequencies_in_document_;
    //std::map<int, std::map<std::string, double>> word_frequencies_in_document_;
    //std::map<std::string, double> empty_;



    bool IsStopWord(const std::string_view word) const;
    std::vector<std::string_view> SplitIntoWordsNoStop(const std::string_view text) const;
    //std::vector<std::string> SplitIntoWordsNoStop(const std::string& text) const;
    static int ComputeAverageRating(const std::vector<int>& ratings);

    struct QueryWord {
        std::string_view data;
        bool is_minus;
        bool is_stop;
    };

    QueryWord ParseQueryWord(std::string_view text) const;

    //struct Query {
    //    std::vector<std::string> plus_words;
    //    std::vector<std::string> minus_words;
    //};

    struct Query {
        std::vector<std::string_view> plus_words;
        std::vector<std::string_view> minus_words;
    };

    //Query ParseQuery(const std::string& text, bool sequenced_policy = true) const;
    Query ParseQuery(const std::string_view text, bool sequenced_policy = true) const;
    // Existence required
    double ComputeWordInverseDocumentFreq(const std::string_view word) const;

    template <typename DocumentPredicate>
    std::vector<Document> FindAllDocuments(const Query& query, DocumentPredicate document_predicate) const;

    //static bool IsValidWord(const std::string& word);
    static bool IsValidWord(const std::string_view word);
};

template <typename StringContainer>
SearchServer::SearchServer(const StringContainer& stop_words)
    : stop_words_(MakeUniqueNonEmptyStrings(stop_words)) {
    for (const auto& word : stop_words) {
        if (!IsValidWord(word)) {
            throw std::invalid_argument("Стоп-слово \""s + std::string(word) + "\" содержит недопустимые символы."s);
        }
    }
}

template <typename DocumentPredicate>
std::vector<Document> SearchServer::FindTopDocuments(const std::string_view raw_query, DocumentPredicate document_predicate) const {
    //LOG_DURATION_STREAM("FindTopDocuments"s, std::cout);
    const Query query = ParseQuery(raw_query);
    if (!IsValidWord(raw_query)) {
        throw std::invalid_argument("Содержимое запроса содержит недопустимые символы"s);
    }
    std::vector<Document> matched_documents = FindAllDocuments(query, document_predicate);
    sort(matched_documents.begin(), matched_documents.end(), [](const Document& lhs, const Document& rhs) {
        if (std::abs(lhs.relevance - rhs.relevance) < DELTA) {
            return lhs.rating > rhs.rating;
        } else {
            return lhs.relevance > rhs.relevance;
        }
        });
    if (matched_documents.size() > MAX_RESULT_DOCUMENT_COUNT) {
        matched_documents.resize(MAX_RESULT_DOCUMENT_COUNT);
    }
    return matched_documents;
}

template <typename DocumentPredicate>
std::vector<Document> SearchServer::FindAllDocuments(const SearchServer::Query& query, DocumentPredicate document_predicate) const {
    std::map<int, double> document_to_relevance;
    for (const std::string_view word : query.plus_words) {
        if (word_to_document_freqs_.count(word) == 0) {
            continue;
        }
        const double inverse_document_freq = ComputeWordInverseDocumentFreq(word);
        for (const auto& [document_id, term_freq] : word_to_document_freqs_.at(word)) {
            const auto& document_data = documents_.at(document_id);
            if (document_predicate(document_id, document_data.status, document_data.rating)) {
                document_to_relevance[document_id] += term_freq * inverse_document_freq;
            }
        }
    }

    for (const std::string_view word : query.minus_words) {
        if (word_to_document_freqs_.count(word) == 0) {
            continue;
        }
        for (const auto [document_id, _] : word_to_document_freqs_.at(word)) {
            document_to_relevance.erase(document_id);
        }
    }

    std::vector<Document> matched_documents;
    for (const auto [document_id, relevance] : document_to_relevance) {
        matched_documents.push_back({ document_id, relevance, documents_.at(document_id).rating });
    }
    return matched_documents;
}