#include "Bitstream.hpp"
#include "Chip.hpp"
#include "ChipConfig.hpp"
#include "Database.hpp"
#include "Tile.hpp"
#include "BitDatabase.hpp"
#include "TileConfig.hpp"
#include "RoutingGraph.hpp"
#include "DedupChipdb.hpp"

#include <vector>
#include <string>
#include <iostream>

#ifdef INCLUDE_PYTHON

#include <boost/python.hpp>

#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
#include <boost/python/suite/indexing/map_indexing_suite.hpp>
#include <boost/python/exception_translator.hpp>
#include "set_indexing_suite.h"

using namespace boost::python;
using namespace Trellis;

void translate_bspe(const BitstreamParseError &e)
{
    // Use the Python 'C' API to set up an exception object
    PyErr_SetString(PyExc_ValueError, e.what());
}

void translate_dbce(const DatabaseConflictError &e)
{
    // Use the Python 'C' API to set up an exception object
    PyErr_SetString(PyExc_ValueError, e.what());
}


BOOST_PYTHON_MODULE (pytrellis)
{
    // Common Types
    class_<vector<string>>("StringVector")
            .def(vector_indexing_suite<vector<string>>());

    class_<vector<uint8_t>>("ByteVector")
            .def(vector_indexing_suite<vector<uint8_t>>());

    class_<vector<bool>>("BoolVector")
            .def(vector_indexing_suite<vector<bool>>());

    class_<std::pair<int, int> >("IntPair")
            .def_readwrite("first", &std::pair<int, int>::first)
            .def_readwrite("second", &std::pair<int, int>::second);

    // From Bitstream.cpp
    register_exception_translator<BitstreamParseError>(&translate_bspe);
    class_<Bitstream>("Bitstream", no_init)
            .def("read_bit", &Bitstream::read_bit_py)
            .staticmethod("read_bit")
            .def("serialise_chip", &Bitstream::serialise_chip_py)
            .staticmethod("serialise_chip")
            .def("serialise_chip_delta", &Bitstream::serialise_chip_delta_py)
            .staticmethod("serialise_chip_delta")
            .def("write_bit", &Bitstream::write_bit_py)
            .def_readwrite("metadata", &Bitstream::metadata)
            .def_readwrite("data", &Bitstream::data)
        .def("deserialise_chip", static_cast<Chip (Bitstream::*)()>(&Bitstream::deserialise_chip));

    class_<DeviceLocator>("DeviceLocator")
            .def_readwrite("family", &DeviceLocator::family)
            .def_readwrite("device", &DeviceLocator::device);

    class_<TileLocator>("TileLocator", init<string, string, string>())
            .def_readwrite("family", &TileLocator::family)
            .def_readwrite("device", &TileLocator::device)
            .def_readwrite("tiletype", &TileLocator::tiletype);

    // From Chip.cpp
    class_<ChipInfo>("ChipInfo")
            .def_readwrite("name", &ChipInfo::name)
            .def_readwrite("family", &ChipInfo::family)
            .def_readwrite("idcode", &ChipInfo::idcode)
            .def_readonly("num_frames", &ChipInfo::num_frames)
            .def_readonly("bits_per_frame", &ChipInfo::bits_per_frame)
            .def_readonly("pad_bits_before_frame", &ChipInfo::pad_bits_before_frame)
            .def_readonly("pad_bits_after_frame", &ChipInfo::pad_bits_after_frame)
            .def_readonly("max_row", &ChipInfo::max_row)
            .def_readonly("max_col", &ChipInfo::max_col)
            .def_readonly("col_bias", &ChipInfo::col_bias);

    class_<map<string, shared_ptr<Tile>>>("TileMap")
            .def(map_indexing_suite<map<string, shared_ptr<Tile>>, true>());

    class_<vector<shared_ptr<Tile>>>("TileVector")
            .def(vector_indexing_suite<vector<shared_ptr<Tile>>, true>());

    class_<GlobalRegion>("GlobalRegion")
            .def_readwrite("name", &GlobalRegion::name)
            .def_readwrite("x0", &GlobalRegion::x0)
            .def_readwrite("y0", &GlobalRegion::y0)
            .def_readwrite("x1", &GlobalRegion::x1)
            .def_readwrite("y1", &GlobalRegion::y1)
            .def("matches", &GlobalRegion::matches);

    class_<vector<GlobalRegion>>("GlobalRegionVector")
            .def(vector_indexing_suite<vector<GlobalRegion>>());

    class_<TapSegment>("TapSegment")
            .def_readwrite("tap_col", &TapSegment::tap_col)
            .def_readwrite("lx0", &TapSegment::lx0)
            .def_readwrite("lx1", &TapSegment::lx1)
            .def_readwrite("rx0", &TapSegment::rx0)
            .def_readwrite("rx1", &TapSegment::rx1)
            .def("matches_left", &TapSegment::matches_left)
            .def("matches_right", &TapSegment::matches_right);

    enum_<TapDriver::TapDir>("TapDir")
            .value("LEFT", TapDriver::LEFT)
            .value("RIGHT", TapDriver::RIGHT);

    class_<TapDriver>("TapDriver")
            .def_readwrite("col", &TapDriver::col)
            .def_readwrite("dir", &TapDriver::dir);

    class_<vector<TapSegment>>("TapSegmentVector")
            .def(vector_indexing_suite<vector<TapSegment>>());

    class_<GlobalsInfo>("GlobalsInfo")
            .def_readwrite("quadrants", &GlobalsInfo::quadrants)
            .def_readwrite("tapsegs", &GlobalsInfo::tapsegs)
            .def("get_quadrant", &GlobalsInfo::get_quadrant)
            .def("get_tap_driver", &GlobalsInfo::get_tap_driver)
            .def("get_spine_driver", &GlobalsInfo::get_spine_driver);

    class_<Chip>("Chip", init<string>())
            .def(init<uint32_t>())
            .def(init<const ChipInfo &>())
            .def("get_tile_by_name", &Chip::get_tile_by_name)
            .def("get_tiles_by_position", &Chip::get_tiles_by_position)
            .def("get_tiles_by_type", &Chip::get_tiles_by_type)
            .def("get_all_tiles", &Chip::get_all_tiles)
            .def("get_max_row", &Chip::get_max_row)
            .def("get_max_col", &Chip::get_max_col)
            .def("get_routing_graph", &Chip::get_routing_graph)
            .def_readonly("info", &Chip::info)
            .def_readwrite("cram", &Chip::cram)
            .def_readwrite("tiles", &Chip::tiles)
            .def_readwrite("usercode", &Chip::usercode)
            .def_readwrite("metadata", &Chip::metadata)
            .def_readwrite("global_data", &Chip::global_data)
            .def(self - self);

    class_<ChipDelta>("ChipDelta")
            .def(map_indexing_suite<ChipDelta>());

    // From CRAM.cpp
    class_<ChangedBit>("ChangedBit")
            .def_readonly("frame", &ChangedBit::frame)
            .def_readonly("bit", &ChangedBit::bit)
            .def_readonly("delta", &ChangedBit::delta);

    class_<CRAMView>("CRAMView", no_init)
            .def("bit", &CRAMView::get_bit)
            .def("set_bit", &CRAMView::set_bit)
            .def("bits", &CRAMView::bits)
            .def("frames", &CRAMView::frames)
            .def("clear", &CRAMView::clear)
            .def(self - self);

    class_<CRAM>("CRAM", init<int, int>())
            .def("bit", &CRAM::get_bit)
            .def("set_bit", &CRAM::set_bit)
            .def("bits", &CRAM::bits)
            .def("frames", &CRAM::frames)
            .def("make_view", &CRAM::make_view);

    class_<CRAMDelta>("CRAMDelta")
            .def(vector_indexing_suite<CRAMDelta>());

    // From Tile.cpp
    def("get_row_col_pair_from_chipsize", get_row_col_pair_from_chipsize);

    class_<vector<SiteInfo>>("SiteInfoVector")
            .def(vector_indexing_suite<vector<SiteInfo>>());

    class_<SiteInfo>("SiteInfo")
            .def_readonly("type", &SiteInfo::type)
            .def_readonly("row", &SiteInfo::row)
            .def_readonly("col", &SiteInfo::col);

    class_<TileInfo>("TileInfo")
            .def_readonly("name", &TileInfo::name)
            .def_readonly("type", &TileInfo::type)
            .def_readonly("num_frames", &TileInfo::num_frames)
            .def_readonly("bits_per_frame", &TileInfo::bits_per_frame)
            .def_readonly("frame_offset", &TileInfo::frame_offset)
            .def_readonly("bit_offset", &TileInfo::bit_offset)
            .def_readonly("sites", &TileInfo::sites)
            .def("get_row_col", &TileInfo::get_row_col);

    class_<Tile, shared_ptr<Tile>>("Tile", no_init)
            .def_readonly("info", &Tile::info)
            .def_readwrite("cram", &Tile::cram)
            .def_readwrite("known_bits", &Tile::known_bits)
            .def_readwrite("unknown_bits", &Tile::unknown_bits)
            .def("dump_config", &Tile::dump_config)
            .def("read_config", &Tile::read_config);

    // From Database.cpp
    def("load_database", load_database);
    def("find_device_by_name", find_device_by_name);
    def("find_device_by_idcode", find_device_by_idcode);
    def("get_chip_info", get_chip_info);
    def("get_device_tilegrid", get_device_tilegrid);
    def("get_tile_bitdata", get_tile_bitdata);

    // From BitDatabase.cpp
    register_exception_translator<DatabaseConflictError>(&translate_dbce);
    class_<ConfigBit>("ConfigBit")
            .def_readwrite("frame", &ConfigBit::frame)
            .def_readwrite("bit", &ConfigBit::bit)
            .def_readwrite("inv", &ConfigBit::inv);

    def("cbit_from_str", cbit_from_str);
    class_<vector<ConfigBit>>("ConfigBitVector")
            .def(vector_indexing_suite<vector<ConfigBit>>());
    class_<set<ConfigBit>>("ConfigBitSet")
            .def(bond::python::set_indexing_suite<set<ConfigBit>, true>());

    class_<BitGroup>("BitGroup")
            .def(init<const CRAMDelta &>())
            .def_readwrite("bits", &BitGroup::bits)
            .def("match", &BitGroup::match)
            .def("add_coverage", &BitGroup::add_coverage)
            .def("set_group", &BitGroup::set_group)
            .def("clear_group", &BitGroup::clear_group);

    class_<vector<BitGroup>>("BitGroupVector")
            .def(vector_indexing_suite<vector<BitGroup>>());

    class_<ArcData>("ArcData")
            .def_readwrite("source", &ArcData::source)
            .def_readwrite("sink", &ArcData::sink)
            .def_readwrite("bits", &ArcData::bits);

    class_<map<string, ArcData>>("ArcDataMap")
            .def(map_indexing_suite<map<string, ArcData>>());

    class_<MuxBits>("MuxBits")
            .def_readwrite("sink", &MuxBits::sink)
            .def_readwrite("arcs", &MuxBits::arcs)
            .def("get_sources", &MuxBits::get_sources)
            .def("get_driver", &MuxBits::get_driver)
            .def("set_driver", &MuxBits::set_driver);

    class_<WordSettingBits>("WordSettingBits")
            .def_readwrite("name", &WordSettingBits::name)
            .def_readwrite("bits", &WordSettingBits::bits)
            .def_readwrite("defval", &WordSettingBits::defval)
            .def("get_value", &WordSettingBits::get_value)
            .def("set_value", &WordSettingBits::set_value);

    class_<map<string, BitGroup>>("BitGroupMap")
            .def(map_indexing_suite<map<string, BitGroup>>());

    class_<EnumSettingBits>("EnumSettingBits")
            .def_readwrite("name", &EnumSettingBits::name)
            .def_readwrite("options", &EnumSettingBits::options)
            .def("get_options", &EnumSettingBits::get_options)
            .add_property("defval", &EnumSettingBits::get_defval, &EnumSettingBits::set_defval)
            .def("get_value", &EnumSettingBits::get_value)
            .def("set_value", &EnumSettingBits::set_value);

    class_<FixedConnection>("FixedConnection")
            .def_readwrite("source", &FixedConnection::source)
            .def_readwrite("sink", &FixedConnection::sink);

    class_<vector<FixedConnection>>("FixedConnectionVector")
            .def(vector_indexing_suite<vector<FixedConnection>>());

    class_<TileBitDatabase, shared_ptr<TileBitDatabase>>("TileBitDatabase", no_init)
            .def("config_to_tile_cram", &TileBitDatabase::config_to_tile_cram)
            .def("tile_cram_to_config", &TileBitDatabase::tile_cram_to_config)
            .def("get_sinks", &TileBitDatabase::get_sinks)
            .def("get_mux_data_for_sink", &TileBitDatabase::get_mux_data_for_sink)
            .def("get_settings_words", &TileBitDatabase::get_settings_words)
            .def("get_data_for_setword", &TileBitDatabase::get_data_for_setword)
            .def("get_settings_enums", &TileBitDatabase::get_settings_enums)
            .def("get_data_for_enum", &TileBitDatabase::get_data_for_enum)
            .def("get_fixed_conns", &TileBitDatabase::get_fixed_conns)
            .def("get_downhill_wires", &TileBitDatabase::get_downhill_wires)
            .def("add_mux_arc", &TileBitDatabase::add_mux_arc)
            .def("add_setting_word", &TileBitDatabase::add_setting_word)
            .def("add_setting_enum", &TileBitDatabase::add_setting_enum)
            .def("add_fixed_conn", &TileBitDatabase::add_fixed_conn)
            .def("remove_fixed_sink", &TileBitDatabase::remove_fixed_sink)
            .def("remove_setting_word", &TileBitDatabase::remove_setting_word)
            .def("remove_setting_enum", &TileBitDatabase::remove_setting_enum)
            .def("save", &TileBitDatabase::save);

    typedef pair<string, bool> StringBoolPair;
    typedef pair<string, bool> StringBoolPair;
    class_<StringBoolPair>("StringBoolPair")
            .def_readwrite("first", &StringBoolPair::first)
            .def_readwrite("second", &StringBoolPair::second);

    class_<vector<StringBoolPair>>("StringBoolPairVector")
            .def(vector_indexing_suite<vector<StringBoolPair>>());

    // From TileConfig.hpp
    class_<ConfigArc>("ConfigArc")
            .def_readwrite("source", &ConfigArc::source)
            .def_readwrite("sink", &ConfigArc::sink);
    class_<ConfigWord>("ConfigWord")
            .def_readwrite("name", &ConfigWord::name)
            .def_readwrite("value", &ConfigWord::value);
    class_<ConfigEnum>("ConfigEnum")
            .def_readwrite("name", &ConfigEnum::name)
            .def_readwrite("value", &ConfigEnum::value);
    class_<ConfigUnknown>("ConfigUnknown")
            .def_readwrite("frame", &ConfigUnknown::frame)
            .def_readwrite("bit", &ConfigUnknown::bit);

    class_<vector<ConfigArc>>("ConfigArcVector")
            .def(vector_indexing_suite<vector<ConfigArc>>());
    class_<vector<ConfigWord>>("ConfigWordVector")
            .def(vector_indexing_suite<vector<ConfigWord>>());
    class_<vector<ConfigEnum>>("ConfigEnumVector")
            .def(vector_indexing_suite<vector<ConfigEnum>>());
    class_<vector<ConfigUnknown>>("ConfigUnknownVector")
            .def(vector_indexing_suite<vector<ConfigUnknown>>());

    class_<TileConfig>("TileConfig")
            .def_readwrite("carcs", &TileConfig::carcs)
            .def_readwrite("cwords", &TileConfig::cwords)
            .def_readwrite("cenums", &TileConfig::cenums)
            .def_readwrite("cunknowns", &TileConfig::cunknowns)
            .def("add_arc", &TileConfig::add_arc)
            .def("add_enum", &TileConfig::add_enum)
            .def("add_word", &TileConfig::add_word)
            .def("add_unknown", &TileConfig::add_unknown)
            .def("to_string", &TileConfig::to_string)
            .def("from_string", &TileConfig::from_string)
            .staticmethod("from_string");

    // From ChipConfig.hpp
    class_<map<string, TileConfig>>("TileConfigMap")
            .def(map_indexing_suite<map<string, TileConfig>>());
    class_<vector<uint16_t>>("Uint16Vector")
            .def(vector_indexing_suite<vector<uint16_t>>());
    class_<map<uint16_t, vector<uint16_t>>>("Uint16VMap")
            .def(map_indexing_suite<map<uint16_t, vector<uint16_t>>>());

    class_<ChipConfig>("ChipConfig")
            .def_readwrite("chip_name", &ChipConfig::chip_name)
            .def_readwrite("metadata", &ChipConfig::metadata)
            .def_readwrite("tiles", &ChipConfig::tiles)
            .def_readwrite("tilegroups", &ChipConfig::tilegroups)
            .def_readwrite("bram_data", &ChipConfig::bram_data)
            .def("to_string", &ChipConfig::to_string)
            .def("from_string", &ChipConfig::from_string)
            .staticmethod("from_string")
            .def("to_chip", &ChipConfig::to_chip)
            .def("from_chip", &ChipConfig::from_chip)
            .staticmethod("from_chip");

    // From RoutingGraph.hpp
    class_<Location>("Location", init<int, int>())
            .def_readwrite("x", &Location::x)
            .def_readwrite("y", &Location::y)
            .def(self + self)
            .def(self == self)
            .def(self != self);

    class_<RoutingId>("RoutingId")
            .def_readwrite("loc", &RoutingId::loc)
            .def_readwrite("id", &RoutingId::id)
            .def(self == self)
            .def(self != self);

    class_<vector<RoutingId>>("RoutingIdVector")
            .def(vector_indexing_suite<vector<RoutingId>>());

    typedef pair<RoutingId, ident_t> BelPin;
    class_<BelPin>("BelPin")
            .def_readwrite("bel", &BelPin::first)
            .def_readwrite("pin", &BelPin::second);

    typedef pair<RoutingId, PortDirection> BelWireDir;
    class_<BelWireDir>("BelWireDir")
            .def_readwrite("wire", &BelWireDir::first)
            .def_readwrite("dir", &BelWireDir::second);

    enum_<PortDirection>("PortDirection")
            .value("PORT_IN", PORT_IN)
            .value("PORT_OUT", PORT_OUT)
            .value("PORT_INOUT", PORT_INOUT);

    class_<vector<BelPin>>("BelPinVector")
            .def(vector_indexing_suite<vector<BelPin>>());

    class_<RoutingWire>("RoutingWire")
            .def_readwrite("id", &RoutingWire::id)
            .def_readwrite("uphill", &RoutingWire::uphill)
            .def_readwrite("downhill", &RoutingWire::downhill)
            .def_readwrite("belsUphill", &RoutingWire::belsUphill)
            .def_readwrite("belsDownhill", &RoutingWire::belsDownhill);

    class_<RoutingArc>("RoutingArc")
            .def_readwrite("id", &RoutingArc::id)
            .def_readwrite("tiletype", &RoutingArc::tiletype)
            .def_readwrite("source", &RoutingArc::source)
            .def_readwrite("sink", &RoutingArc::sink)
            .def_readwrite("configurable", &RoutingArc::configurable);

    class_<map<ident_t, BelWireDir>>("RoutingPinMap")
            .def(map_indexing_suite<map<ident_t, BelWireDir>>());

    class_<RoutingBel>("RoutingBel")
            .def_readwrite("name", &RoutingBel::name)
            .def_readwrite("type", &RoutingBel::type)
            .def_readwrite("pins", &RoutingBel::pins)
            .def_readwrite("z", &RoutingBel::z);

    class_<map<ident_t, RoutingWire>>("RoutingWireMap")
            .def(map_indexing_suite<map<ident_t, RoutingWire>>());

    class_<map<ident_t, RoutingArc>>("RoutingArcMap")
            .def(map_indexing_suite<map<ident_t, RoutingArc>>());

    class_<map<ident_t, RoutingBel>>("RoutingBelMap")
            .def(map_indexing_suite<map<ident_t, RoutingBel>>());

    class_<RoutingTileLoc>("RoutingTileLoc")
            .def_readwrite("loc", &RoutingTileLoc::loc)
            .def_readwrite("wires", &RoutingTileLoc::wires)
            .def_readwrite("arcs", &RoutingTileLoc::arcs)
            .def_readwrite("bels", &RoutingTileLoc::bels);

    class_<map<Location, RoutingTileLoc>>("RoutingTileMap")
            .def(map_indexing_suite<map<Location, RoutingTileLoc>>());

    class_<RoutingGraph, shared_ptr<RoutingGraph>>("RoutingGraph", no_init)
            .def_readonly("chip_name", &RoutingGraph::chip_name)
            .def_readonly("max_row", &RoutingGraph::max_row)
            .def_readonly("max_col", &RoutingGraph::max_col)
            .def("ident", &RoutingGraph::ident)
            .def("to_str", &RoutingGraph::to_str)
            .def("id_at_loc", &RoutingGraph::id_at_loc)
            .def_readwrite("tiles", &RoutingGraph::tiles)
            .def("globalise_net", &RoutingGraph::globalise_net)
            .def("add_arc", &RoutingGraph::add_arc)
            .def("add_wire", &RoutingGraph::add_wire);

    // DedupChipdb
    using namespace DDChipDb;
    class_<RelId>("RelId")
            .def_readwrite("rel", &RelId::rel)
            .def_readwrite("id", &RelId::id)
            .def(self == self)
            .def(self != self);

    class_<BelPort>("BelPort")
            .def_readwrite("bel", &BelPort::bel)
            .def_readwrite("pin", &BelPort::pin);
    class_<BelWire>("BelWire")
            .def_readwrite("wire", &BelWire::wire)
            .def_readwrite("pin", &BelWire::pin)
            .def_readwrite("dir", &BelWire::dir);

    class_<vector<BelPort>>("BelPortVector")
            .def(vector_indexing_suite<vector<BelPort>>());
    class_<vector<BelWire>>("BelWireVector")
            .def(vector_indexing_suite<vector<BelWire>>());
    class_<vector<RelId>>("RelIdVector")
            .def(vector_indexing_suite<vector<RelId>>());
    class_<set<RelId>>("RelIdSet")
            .def(bond::python::set_indexing_suite<set<RelId>,true>());

    enum_<ArcClass>("ArcClass")
            .value("ARC_STANDARD", ARC_STANDARD)
            .value("ARC_FIXED", ARC_FIXED);
    class_<DdArcData>("DdArcData")
            .def_readwrite("srcWire", &DdArcData::srcWire)
            .def_readwrite("sinkWire", &DdArcData::sinkWire)
            .def_readwrite("cls", &DdArcData::cls)
            .def_readwrite("delay", &DdArcData::delay)
            .def_readwrite("tiletype", &DdArcData::tiletype);

    class_<WireData>("WireData")
            .def_readwrite("name", &WireData::name)
            .def_readwrite("arcsDownhill", &WireData::arcsDownhill)
            .def_readwrite("arcsUphill", &WireData::arcsUphill)
            .def_readwrite("belPins", &WireData::belPins);

    class_<BelData>("BelData")
            .def_readwrite("name", &BelData::name)
            .def_readwrite("type", &BelData::type)
            .def_readwrite("z", &BelData::z)
            .def_readwrite("wires", &BelData::wires);

    class_<vector<BelData>>("BelDataVector")
            .def(vector_indexing_suite<vector<BelData>>());
    class_<vector<WireData>>("WireDataVector")
            .def(vector_indexing_suite<vector<WireData>>());
    class_<vector<DdArcData>>("DdArcDataVector")
            .def(vector_indexing_suite<vector<DdArcData>>());

    class_<LocationData>("LocationData")
            .def_readwrite("wires", &LocationData::wires)
            .def_readwrite("arcs", &LocationData::arcs)
            .def_readwrite("bels", &LocationData::bels)
            .def("checksum", &LocationData::checksum);

    class_<map<Location, checksum_t>>("LocationMap")
            .def(map_indexing_suite<map<Location, checksum_t>>());

    class_<map<checksum_t, LocationData>>("LocationTypesMap")
            .def(map_indexing_suite<map<checksum_t, LocationData>>());

    class_<checksum_t>("checksum_t")
            .def_readwrite("first", &checksum_t::first)
            .def_readwrite("second", &checksum_t::second)
            .def(self == self);

    class_<DedupChipdb, shared_ptr<DedupChipdb>>("DedupChipdb")
            .def_readwrite("locationTypes", &DedupChipdb::locationTypes)
            .def_readwrite("typeAtLocation", &DedupChipdb::typeAtLocation)
            .def("get_cs_data", &DedupChipdb::get_cs_data)
            .def("ident", &DedupChipdb::ident)
            .def("to_str", &DedupChipdb::to_str);

    def("make_dedup_chipdb", make_dedup_chipdb);
}

#endif