/*
 * Copyright (c) 2003-2009, John Wiegley.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * - Neither the name of New Artisans LLC nor the names of its
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <system.hh>

#include "pyinterp.h"
#include "mask.h"
#include "item.h"

namespace ledger {

using namespace boost::python;

namespace {

  bool py_has_tag_1s(item_t& item, const string& tag) {
    return item.has_tag(tag);
  }
  bool py_has_tag_1m(item_t& item, const mask_t& tag_mask) {
    return item.has_tag(tag_mask);
  }
  bool py_has_tag_2m(item_t& item, const mask_t& tag_mask,
		     const boost::optional<mask_t>& value_mask) {
    return item.has_tag(tag_mask, value_mask);
  }

  boost::optional<string> py_get_tag_1s(item_t& item, const string& tag) {
    return item.get_tag(tag);
  }
  boost::optional<string> py_get_tag_1m(item_t& item, const mask_t& tag_mask) {
    return item.get_tag(tag_mask);
  }
  boost::optional<string> py_get_tag_2m(item_t& item, const mask_t& tag_mask,
					const boost::optional<mask_t>& value_mask) {
    return item.get_tag(tag_mask, value_mask);
  }

} // unnamed namespace

#define EXC_TRANSLATOR(type)				\
  void exc_translate_ ## type(const type& err) {	\
    PyErr_SetString(PyExc_ArithmeticError, err.what());	\
  }

//EXC_TRANSLATOR(item_error)

void export_item()
{
  class_< position_t > ("Position")
    .add_property("pathname",
		  make_getter(&position_t::pathname),
		  make_setter(&position_t::pathname))
    .add_property("beg_pos",
		  make_getter(&position_t::beg_pos),
		  make_setter(&position_t::beg_pos))
    .add_property("beg_line",
		  make_getter(&position_t::beg_line),
		  make_setter(&position_t::beg_line))
    .add_property("end_pos",
		  make_getter(&position_t::end_pos),
		  make_setter(&position_t::end_pos))
    .add_property("end_line",
		  make_getter(&position_t::end_line),
		  make_setter(&position_t::end_line))
    ;

  scope().attr("ITEM_NORMAL")	 = ITEM_NORMAL;
  scope().attr("ITEM_GENERATED") = ITEM_GENERATED;
  scope().attr("ITEM_TEMP")	 = ITEM_TEMP;

  class_< item_t > ("Item", init<uint_least8_t>())
#if 1
    .def("flags", &supports_flags<>::flags)
    .def("has_flags", &supports_flags<>::has_flags)
    .def("set_flags", &supports_flags<>::set_flags)
    .def("clear_flags", &supports_flags<>::clear_flags)
    .def("add_flags", &supports_flags<>::add_flags)
    .def("drop_flags", &supports_flags<>::drop_flags)
#endif

    .add_property("note",
		  make_getter(&item_t::note),
		  make_setter(&item_t::note))
    .add_property("pos",
		  make_getter(&item_t::pos),
		  make_setter(&item_t::pos))
    .add_property("metadata",
		  make_getter(&item_t::metadata),
		  make_setter(&item_t::metadata))

    .def("copy_details", &item_t::copy_details)

    .def(self == self)
    .def(self != self)

    .def("has_tag", py_has_tag_1s)
    .def("has_tag", py_has_tag_1m)
    .def("has_tag", py_has_tag_2m)
    .def("get_tag", py_get_tag_1s)
    .def("get_tag", py_get_tag_1m)
    .def("get_tag", py_get_tag_2m)

    .def("set_tag", &item_t::set_tag)

    .def("parse_tags", &item_t::parse_tags)
    .def("append_note", &item_t::append_note)

    .add_static_property("use_effective_date",
			 make_getter(&item_t::use_effective_date),
			 make_setter(&item_t::use_effective_date))

    .def("date", &item_t::date)
    .def("effective_date", &item_t::effective_date)

    .def("set_state", &item_t::set_state)
    .def("state", &item_t::state)

    .def("lookup", &item_t::lookup)

    .def("valid", &item_t::valid)
    ;
}

} // namespace ledger