#pragma once

#include <algorithm>
#include <set>
#include <vector>
#include <map>
#include <ostream>
#include <memory>

namespace ddkit {
namespace utils {
namespace container {

template <typename Container, typename Value>
bool contains(Container container, Value value) {
    return std::find(container.begin(), container.end(), value) != container.end();
}

template <typename T>
std::vector<T> set2vector(std::set<T> p_set) {
    std::vector<T> r_vec;
    std::copy(p_set.begin(), p_set.end(), std::back_inserter(r_vec));
    return r_vec;
}

template <typename T>
std::set<T> vector2set(std::vector<T> p_vec) {
    std::set<T> r_set;
    std::copy(p_vec.begin(), p_vec.end(), std::inserter(r_set, r_set.begin()));
    return r_set;
}

template <typename T>
typename std::set<T> set_difference(typename std::set<T> const& minuend, typename std::set<T> const& subtrahend) {
    std::set<T> diff;
    std::set_difference(
        minuend.begin(),
        minuend.end(),
        subtrahend.begin(),
        subtrahend.end(),
        std::inserter(diff, diff.end()));
    return diff;
}


template <typename T>
typename std::vector<T> vector_difference(typename std::vector<T> const& minuend, typename std::vector<T> const& subtrahend) {
    std::vector<T> diff;

    std::copy_if(minuend.begin(), minuend.end(), std::back_inserter(diff), [subtrahend](const T& element) {
        return !contains(subtrahend, element);
    });
    return diff;
}

inline std::string quotify(const std::string& input) { return "\"" + input+ "\""; }
template<typename T> T quotify(T t) { return t; }

template <typename T>
std::ostream& operator<<(std::ostream& s, std::vector<T> rhs) {
    bool isFirst = true;
    s << "[";
    for (auto const& i : rhs) {
        if (isFirst) isFirst = false;
        else s << ", ";
        s << quotify<T>(i);
    }
    s << "]";
    return s;
}

template <typename T, typename U>
std::ostream& operator<<(std::ostream& s, std::pair<T, U> rhs) {
    return s << rhs.first << ":" << quotify<U>(rhs.second);
}

template <typename T, typename U>
std::ostream& operator<<(std::ostream& s, std::map<T, U> rhs) {
    bool isFirst = true;
    s << "{";
    for (auto const& i : rhs) {
        if (isFirst) isFirst = false;
        else s << ", ";
        s << i;
    }
    s << "}";
    return s;
}

template <typename T>
std::ostream& operator<<(std::ostream& s, std::set<T> rhs) {
    bool isFirst = true;
    s << "[";
    for (auto const& i : rhs) {
        if (isFirst) isFirst = false;
        else s << ", ";
        s << quotify<T>(i);
    }
    s << "]";
    return s;
}

template <typename T>
std::ostream& operator<<(std::ostream& s, std::weak_ptr<T> rhs) {
    if(rhs.expired()){
        s << "<expired>";
    } else {
        s << rhs.lock();
    }
    return s;
}

} // container
} // utils
using ddkit::utils::container::operator<<;
} // ddkit