#pragma once

#include <image_io.hpp>
#include <fingerprint.hpp>

#include <boost/serialization/access.hpp>
#include <boost/serialization/vector.hpp>

#include <vector>
#include <string>

template <typename Fingerprint, typename Traits = fingerprint_traits<Fingerprint>>
struct image_database {
	using index = size_t;

	void add(std::string filename){
		auto image = open_as_rgb(filename);
		auto fingerprint = Traits::calculate(image);

		filenames.push_back(filename);
		fingerprints.push_back(fingerprint);
	}

	std::string filename(index i) const {
		return filenames.at(i);
	}

	Fingerprint fingerprint(index i) const {
		return fingerprints.at(i);
	}

	auto size() const {
		return fingerprints.size();
	}

	index nearest_image(raw_rgb_image const & image) const {
		auto fingerprint = Traits::calculate(image);

		index best_index = 0;
		auto best_distance = Traits::distance(fingerprint, fingerprints[0]);

		for(index i = 1; i < fingerprints.size(); ++i){
			auto distance = Traits::distance(fingerprint, fingerprints[i]);
			if(distance < best_distance) {
				best_distance = distance;
				best_index = i;
			}
		}

		return best_index;
	}

private:
	friend class boost::serialization::access;
	template<class Archive>
	void serialize(Archive & ar, const unsigned int /*version*/){
		ar & filenames;
		ar & fingerprints;
	}

	std::vector<std::string> filenames;
	std::vector<Fingerprint> fingerprints;
};