#include "wrap.h"
#include <saga.hpp>

#include <vector>

template <typename T> class mytask
{
  public:
    T          r_;
    saga::task t_;

    mytask (void) { };
   ~mytask (void) { };
};

template <typename T> class saga_object_registry
{
  private:
    std::vector <T> reg_;

  public:
    saga_object_registry (void) { };
   ~saga_object_registry (void) { };

    T   get (int i) { return (reg_[i]); }
    int add (T   o) { 
      reg_.push_back (o); 
      return (reg_.size () - 1);
    }
};

static saga_object_registry <saga::file>     file_registry_;
static saga_object_registry <mytask<off_t> > task_registry_;

saga_file saga_file_create (const char* url)
{
  saga::file f (url);

  return (file_registry_.add (f));
}

off_t saga_file_get_size (saga_file f)
{
  saga::file ff = file_registry_.get (f);

  return (ff.get_size ());
}


saga_task saga_file_task_get_size (saga_file f)
{
  saga::file ff = file_registry_.get (f);

  mytask <off_t> mt;

  saga::task t = ff.get_size <saga::task::Async> (mt.r_);
  t.wait (); // WTF?

  mt.t_ = t;

  return (task_registry_.add (mt));
}

void saga_file_destroy (saga_file f)
{
  // del
}

void saga_task_wait (saga_task t)
{
  mytask <off_t> tt = task_registry_.get (t);

  tt.t_.wait ();
}

off_t saga_task_get_result_offt (saga_task t)
{
  mytask <off_t> tt = task_registry_.get (t);
  return (tt.r_);
}

void saga_task_destroy (saga_task)
{
}