#include "search_server.h"
#include "iterator_range.h"

#include <algorithm>
#include <iterator>
#include <sstream>
#include <iostream>
#include "parse.h"

vector<string> SplitIntoWords( const string& line ) {
  vector<string> res;
  for ( auto x: SplitBy(line,' ') )
      res.push_back(move(string(x)));
  return res;
}

vector<string_view> SplitIntoViews( const string& line ) {
    return SplitBy(line,' ');
}


SearchServer::SearchServer(istream& document_input) {
  UpdateDocumentBase(document_input);
}

void SearchServer::UpdateDocumentBase(istream& document_input) {
   InvertedIndex new_index;
   for ( string current_document; getline(document_input, current_document); new_index.Add(move(current_document)) ) ;
   lock_guard<mutex> lock(mtx);
   auto access= this->index.GetAccess();
   swap(access.ref_to_value,new_index);
}

void SearchServer::AddQueriesStream( istream& query_input, ostream& search_results_output ) {
    auto kernel= [this]( istream &qi, ostream &os ) {
        AddQueriesStreamWorker(qi,os);
    };
    async(kernel,ref(query_input),ref(search_results_output));
}

void SearchServer::AddQueriesStreamWorker( istream& query_input, ostream& search_results_output ) {

  int *seen= new int[50100], yes= 0;
  for ( int i= 0; i < 50100; seen[i++]= 0 ) ;
  int *cnt= new int[50100];

  //shared_lock<shared_mutex> lock(mtx);
  for ( string current_query; getline(query_input, current_query); ) {
    ++yes;
    const auto words= SplitIntoViews(current_query);
    {
       auto access = index.GetAccess();
       for (const auto &word : words) {
           list<size_t> vec;
           {
              vec= access.ref_to_value.Lookup(word);
           }
           for ( const auto it: vec ) {
               if ( seen[it] == yes )
                   ++cnt[it];
               else seen[it]= yes, cnt[it]= 1;
           }
       }
    }
    vector<pair<size_t,size_t>> search_results;
    size_t sz;
    {
       sz= this->index.GetAccess().ref_to_value.size();
    }
    for ( int i= 0; i < sz; ++i )
        if ( seen[i] == yes )
            search_results.emplace_back(i,cnt[i]);
    partial_sort(
      begin(search_results),
      min(begin(search_results)+5,end(search_results)),
      end(search_results),
      []( const pair<size_t, size_t> &lhs, const pair<size_t, size_t> &rhs ) {
        int64_t lhs_docid = lhs.first;
        auto lhs_hit_count = lhs.second;
        int64_t rhs_docid = rhs.first;
        auto rhs_hit_count = rhs.second;
        return make_pair(lhs_hit_count, -lhs_docid) > make_pair(rhs_hit_count, -rhs_docid);
      }
    );
    search_results_output << current_query << ':';
    for ( auto [docid, hitcount] : Head(search_results, 5) ) {
      search_results_output << " {"
        << "docid: " << docid << ", "
        << "hitcount: " << hitcount << '}';
    }
    search_results_output << endl;
  }

  //delete[] seen, delete[] cnt;
}

void InvertedIndex::Add( string document ) {
  const size_t docid = docs.size();
  for ( const auto& word : SplitIntoViews(document) ) {
      insert(word);
      assert( find(word) < index.size() );
      index[find(word)].push_back(docid);
  }
  docs.push_back(move(document));
}

const list<size_t>& InvertedIndex::Lookup(const string& word) const {
  auto id= find(word);
  if ( id < +oo )
      return index[id];
  return empty_list;
}

const list<size_t>& InvertedIndex::Lookup(string_view sv) const {
  auto id= find(sv);
  if ( id < +oo )
      return index[id];
  return empty_list;
}