#include<iostream>
#include<fstream>
#include<vector>
#include<set>
#include<unordered_map>
#include<string>
#include<algorithm>
#include<numeric>
#include"spaceship.h"

using namespace std;

    struct Sort
    {
        bool operator()(const Spaceship& s1, const Spaceship& s2)const{
            if(s1.get_name()<s2.get_name()) return true;
            else if(s1.get_name()==s2.get_name()){
                if(s1.get_faction()>s2.get_faction()) return true;
                else if(s1.get_faction()==s2.get_faction()){
                    if(s1.get_gewicht()<s2.get_gewicht()) return true;
                }
            }
            return false;
        }
    };

template<class Key, class Compare = std::less<Key>>
using sorted_set = std::set<Spaceship, Sort>;

int main()
{
    vector<Spaceship> v;

    ifstream input{"spaceship.txt"};
    Spaceship m;
    while (m.read(input))
    {
        v.push_back(m);
    }

    //Aufgabe 1
    //a
    sorted_set make_set(const std::vector<Spaceship>& v)
    {
        sorted_set <Spaceship, Sort> sortiert(v.begin(), v.end());
        /*sorted_set sortiert;
        sortiert.insert(v.begin(), v.end());*/
        return sortiert;
    }
    //b
    std::tuple<Spaceship,Spaceship,Spaceship,Spaceship> find_extremes(const sorted_set& s)
    {
        sorted_set tmp;
        copy_if(s.begin(), s.end(), back_inserter(tmp), [&](const Spaceship& t){
            return t.get_name().find('H')!=string::npos;
        });
        if(tmp.empty())throw runtime_error("Set ist leer!");
        auto it_begin = tmp.begin();
        auto it_end = s.rbegin();               //s.end()
        Spaceship mini = *min_element(it_begin, it_end, [&](const Spaceship& a, const Spaceship&, b){
            return a.get_crew().size()<b.get_crew().size();
        });                                     //s.end()
        Spaceship maxi = *max_element(it_begin, it_end, [&](const Spaceship& a, const Spaceship&, b){
            return a.get_crew().size()<b.get_crew().size();
        });
        return make_tuple(mini, maxi, *it_begin, *it_end);
    }

    //Aufgabe 2
    //a
    double get_mean(const std::vector<Spaceship>& v, Faction faction)
    {
        double counter = accumulate(v.begin(), v.end(), 0.0,[&](double sum, const Spaceship& tmp){
            return sum+(tmp.get_faction()==faction ? 1: 0);
        });
        double summe = accumulate(v.begin(), v.end(), 0.0,[&](double sum, const Spaceship& tmp){
            return sum+(tmp.get_faction()==faction ? tmp.get_weight() : 0);
        });
        double d = summe/counter;
        return d;
    }
    //b
    std::vector<Spaceship> load(const std::vector<Spaceship>& v, int amount)
    {
        vector<Spaceship>res{};
        transform(v.begin(), v.end(), back_inserter(res), [&](const Spaceship& tmp){
            return tmp.get_weight()+amount;
        });
        return res;
    }

    //Aufgabe 3
    //a
    std::unordered_map<Faction,std::set<string>> make_map(const std::vector<Spaceship>& v)
    {
        unordered_map<Faction,set<string>>res{};
        for_each(v.begin(), v.end(), [&res](const Spaceship& tmp){
            res[tmp.get_faction()].insert(tmp.get_name());
        });
        return res;
    }
    //b
    Faction analyze(const std::unordered_map<Faction,std::set<string>>& m)
    {
        pair<Faction, set<string>> maxi =  *max_element(m.begin(), m.end(), [](const pair<Faction, set<string>>& a, pair<Faction, set<string>>& b){
            return a.second.size() < b.second.size();
        });
        return maxi.first;
    }
    return 0;
}