#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include <fstream>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/weak_ptr.hpp>
#include <boost/serialization/list.hpp>

class DownloadObject;
typedef boost::shared_ptr<DownloadObject> DownloadObjectSp;

class DownloadObject {
public:
    DownloadObject(std::string uri, int priority)
        :uri_(uri), pri_(priority) {}
    virtual void downloadCompleted() = 0;
    virtual ~DownloadObject() {}
    const std::string& getUri() const { return uri_; }
    int getPriority() const { return pri_; }
private:
    std::string uri_;
    int pri_;
};

class Downloader {
public:
    void download(DownloadObject *d) {
        // ダウンロード開始
        objs_.push_back(d);
        // ダウンロード完了したとして。。
        for (std::vector<DownloadObject *>::iterator i(objs_.begin());
            i != objs_.end();
            ++i)
            (*i)->downloadCompleted();
    }
    std::vector<DownloadObject *> objs_;
};

class Content;
typedef boost::shared_ptr<Content> ContentSp;
typedef boost::weak_ptr<Content> ContentWp;

class Cache;
typedef boost::shared_ptr<Cache> CacheSp;

class Cache {
public:
    static Cache &getInstance() { 
        static CacheSp cache_;
        if (!cache_) {
            cache_.reset(new Cache);
        }
        return *cache_.get();
    }
    void addContent(const ContentSp& c) {
        contents_.push_back(c);
    }
private:
    std::vector<ContentSp> contents_;
};

class Content:public DownloadObject {
public:
    static ContentSp create(std::string uri, int priority) {
        ContentSp s(new Content(uri, priority));
        s->setWp(s);
        return s;
    }
    virtual ~Content() { std::cout << "Destroyed" << std::endl; }
    virtual void downloadCompleted() {
        std::cout << "downloadCompleted" << std::endl;
        Cache::getInstance().addContent(self_.lock());
    }
private:
    Content(std::string uri, int priority)
        :DownloadObject(uri, priority)
        { std::cout << "Created" << std::endl; }
    void setWp(const ContentSp &sp) { self_ = sp; }
    ContentWp self_;
    // serialize
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive &ar, const unsigned int /* file_version */) 
    {
        ar & BOOST_SERIALIZATION_NVP(self_);
    }
    
    template<class Archive>
    friend
    void save_construct_data(Archive & ar, const Content *p, const unsigned int /* file_version */);
    template<class Archive>
    friend
    void load_construct_data(Archive & ar, Content *p, const unsigned int /* file_version */);

};

template<class Archive>
void save_construct_data(Archive & ar, const Content *p, const unsigned int /* file_version */)
{
    ar & boost::serialization::make_nvp("uri", p->getUri());
    int pri = p->getPriority();
    ar & boost::serialization::make_nvp("priority", pri);
}

template<class Archive>
void load_construct_data(Archive & ar, Content *p, const unsigned int /* file_version */)
{
    std::string uri;
    int pri;
    ar & boost::serialization::make_nvp("uri", uri);
    ar & boost::serialization::make_nvp("priority", pri);
    ::new(p) Content(uri, pri);
}

class Client {
public:
    void addContent(const ContentSp& content)
    {
        colContent_.push_back(content);
    }
    const std::list<ContentSp> &getContentsList() const { return colContent_; }
private:
    // serialize
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive &ar, const unsigned int /* file_version */) 
    {
        ar & BOOST_SERIALIZATION_NVP(colContent_);
    }
    std::list<ContentSp> colContent_;
};

int main()
{
    std::cout << "Test started" << std::endl;
    {
        // serialize
        Client cli;
        cli.addContent(Content::create("hoge", 1));
        cli.addContent(Content::create("fuga", 2));
        cli.addContent(Content::create("pnyo", 3));
        std::ofstream ofs("output2.xml");
        assert(ofs);
        boost::archive::xml_oarchive oa(ofs);
        oa << boost::serialization::make_nvp("cli", cli);
    }
    {
        // de-serialize
        std::ifstream ifs("output2.xml");
        assert(ifs);
        boost::archive::xml_iarchive ia(ifs);
        Client cli;
        ia >> boost::serialization::make_nvp("cli", cli);
        // check
        const std::list<ContentSp> &col = cli.getContentsList();
        std::list<ContentSp>::const_iterator i = col.begin();
        
        assert((*i)->getUri() == "hoge");
        assert((*i)->getPriority() == 1);
        ++i;
        assert((*i)->getUri() == "fuga");
        assert((*i)->getPriority() == 2);
        ++i;
        assert((*i)->getUri() == "pnyo");
        assert((*i)->getPriority() == 3);
        ++i;
        assert(i == col.end());
    }
    std::cout << "Test finished" << std::endl;
}