#ifdef SLIC3RXS
#include <xsinit.h>

namespace Slic3r {

REGISTER_CLASS(ExPolygon, "ExPolygon");
REGISTER_CLASS(ExPolygonCollection, "ExPolygon::Collection");
REGISTER_CLASS(ExtrusionMultiPath, "ExtrusionMultiPath");
REGISTER_CLASS(ExtrusionPath, "ExtrusionPath");
REGISTER_CLASS(ExtrusionLoop, "ExtrusionLoop");
// there is no ExtrusionLoop::Collection or ExtrusionEntity::Collection
REGISTER_CLASS(ExtrusionEntityCollection, "ExtrusionPath::Collection");
REGISTER_CLASS(ExtrusionSimulator, "ExtrusionSimulator");
REGISTER_CLASS(Filler, "Filler");
REGISTER_CLASS(Flow, "Flow");
REGISTER_CLASS(CoolingBuffer, "GCode::CoolingBuffer");
REGISTER_CLASS(GCode, "GCode");
REGISTER_CLASS(GCodePreviewData, "GCode::PreviewData");
REGISTER_CLASS(GCodeSender, "GCode::Sender");
REGISTER_CLASS(Layer, "Layer");
REGISTER_CLASS(SupportLayer, "Layer::Support");
REGISTER_CLASS(LayerRegion, "Layer::Region");
REGISTER_CLASS(Line, "Line");
REGISTER_CLASS(Linef3, "Linef3");
REGISTER_CLASS(PerimeterGenerator, "Layer::PerimeterGenerator");
REGISTER_CLASS(PlaceholderParser, "GCode::PlaceholderParser");
REGISTER_CLASS(Polygon, "Polygon");
REGISTER_CLASS(Polyline, "Polyline");
REGISTER_CLASS(PolylineCollection, "Polyline::Collection");
REGISTER_CLASS(Print, "Print");
REGISTER_CLASS(PrintObject, "Print::Object");
REGISTER_CLASS(PrintRegion, "Print::Region");
REGISTER_CLASS(Model, "Model");
REGISTER_CLASS(ModelMaterial, "Model::Material");
REGISTER_CLASS(ModelObject, "Model::Object");
REGISTER_CLASS(ModelVolume, "Model::Volume");
REGISTER_CLASS(ModelInstance, "Model::Instance");
REGISTER_CLASS(MotionPlanner, "MotionPlanner");
REGISTER_CLASS(BoundingBox, "Geometry::BoundingBox");
REGISTER_CLASS(BoundingBoxf, "Geometry::BoundingBoxf");
REGISTER_CLASS(BoundingBoxf3, "Geometry::BoundingBoxf3");
REGISTER_CLASS(BridgeDetector, "BridgeDetector");
REGISTER_CLASS(Point, "Point");
REGISTER_CLASS(Point3, "Point3");
REGISTER_CLASS(Pointf, "Pointf");
REGISTER_CLASS(Pointf3, "Pointf3");
REGISTER_CLASS(DynamicPrintConfig, "Config");
REGISTER_CLASS(StaticPrintConfig, "Config::Static");
REGISTER_CLASS(PrintObjectConfig, "Config::PrintObject");
REGISTER_CLASS(PrintRegionConfig, "Config::PrintRegion");
REGISTER_CLASS(GCodeConfig, "Config::GCode");
REGISTER_CLASS(PrintConfig, "Config::Print");
REGISTER_CLASS(FullPrintConfig, "Config::Full");
REGISTER_CLASS(Surface, "Surface");
REGISTER_CLASS(SurfaceCollection, "Surface::Collection");
REGISTER_CLASS(PrintObjectSupportMaterial, "Print::SupportMaterial2");
REGISTER_CLASS(TriangleMesh, "TriangleMesh");
REGISTER_CLASS(AppConfig, "GUI::AppConfig");
REGISTER_CLASS(GLShader, "GUI::_3DScene::GLShader");
REGISTER_CLASS(GLVolume, "GUI::_3DScene::GLVolume");
REGISTER_CLASS(GLVolumeCollection, "GUI::_3DScene::GLVolume::Collection");
REGISTER_CLASS(Preset, "GUI::Preset");
REGISTER_CLASS(PresetCollection, "GUI::PresetCollection");
REGISTER_CLASS(PresetBundle, "GUI::PresetBundle");
REGISTER_CLASS(TabIface, "GUI::Tab");
REGISTER_CLASS(PresetUpdater, "PresetUpdater");
REGISTER_CLASS(AppController, "AppController");
REGISTER_CLASS(PrintController, "PrintController");
REGISTER_CLASS(PrintHost, "PrintHost");

SV* ConfigBase__as_hash(ConfigBase* THIS)
{
    HV* hv = newHV();    
    for (auto &key : THIS->keys())
        (void)hv_store(hv, key.c_str(), key.length(), ConfigBase__get(THIS, key), 0);
    return newRV_noinc((SV*)hv);
}

SV* ConfigBase__get(ConfigBase* THIS, const t_config_option_key &opt_key)
{
    ConfigOption *opt = THIS->option(opt_key, false);
    return (opt == nullptr) ? 
        &PL_sv_undef :
        ConfigOption_to_SV(*opt, *THIS->def()->get(opt_key));
}

SV* ConfigOption_to_SV(const ConfigOption &opt, const ConfigOptionDef &def)
{
    switch (def.type) {
    case coFloat:
    case coPercent:
        return newSVnv(static_cast<const ConfigOptionFloat*>(&opt)->value);
    case coFloats:
    case coPercents:
    {
        auto optv = static_cast<const ConfigOptionFloats*>(&opt);
        AV* av = newAV();
        av_fill(av, optv->values.size()-1);
        for (const double &v : optv->values)
            av_store(av, &v - optv->values.data(), newSVnv(v));
        return newRV_noinc((SV*)av);
    }
    case coInt:
        return newSViv(static_cast<const ConfigOptionInt*>(&opt)->value);
    case coInts:
    {
        auto optv = static_cast<const ConfigOptionInts*>(&opt);
        AV* av = newAV();
        av_fill(av, optv->values.size()-1);
        for (const int &v : optv->values)
            av_store(av, &v - optv->values.data(), newSViv(v));
        return newRV_noinc((SV*)av);
    }
    case coString:
    {
        auto optv = static_cast<const ConfigOptionString*>(&opt);
        // we don't serialize() because that would escape newlines
        return newSVpvn_utf8(optv->value.c_str(), optv->value.length(), true);
    }
    case coStrings:
    {
        auto optv = static_cast<const ConfigOptionStrings*>(&opt);
        AV* av = newAV();
        av_fill(av, optv->values.size()-1);
        for (const std::string &v : optv->values)
            av_store(av, &v - optv->values.data(), newSVpvn_utf8(v.c_str(), v.length(), true));
        return newRV_noinc((SV*)av);
    }
    case coPoint:
        return perl_to_SV_clone_ref(static_cast<const ConfigOptionPoint*>(&opt)->value);
    case coPoints:
    {
        auto optv = static_cast<const ConfigOptionPoints*>(&opt);
        AV* av = newAV();
        av_fill(av, optv->values.size()-1);
        for (const Pointf &v : optv->values)
            av_store(av, &v - optv->values.data(), perl_to_SV_clone_ref(v));
        return newRV_noinc((SV*)av);
    }
    case coBool:
        return newSViv(static_cast<const ConfigOptionBool*>(&opt)->value ? 1 : 0);
    case coBools:
    {
        auto optv = static_cast<const ConfigOptionBools*>(&opt);
        AV* av = newAV();
        av_fill(av, optv->values.size()-1);
        for (size_t i = 0; i < optv->values.size(); ++ i)
            av_store(av, i, newSViv(optv->values[i] ? 1 : 0));
        return newRV_noinc((SV*)av);
    }
    default:
        std::string serialized = opt.serialize();
        return newSVpvn_utf8(serialized.c_str(), serialized.length(), true);
    }
}

SV* ConfigBase__get_at(ConfigBase* THIS, const t_config_option_key &opt_key, size_t i)
{
    ConfigOption* opt = THIS->option(opt_key, false);
    if (opt == nullptr)
        return &PL_sv_undef;
    
    const ConfigOptionDef* def = THIS->def()->get(opt_key);
    switch (def->type) {
    case coFloats:
    case coPercents:
        return newSVnv(static_cast<ConfigOptionFloats*>(opt)->get_at(i));
    case coInts:
        return newSViv(static_cast<ConfigOptionInts*>(opt)->get_at(i));
    case coStrings:
    {
        // we don't serialize() because that would escape newlines
        const std::string &val = static_cast<ConfigOptionStrings*>(opt)->get_at(i);
        return newSVpvn_utf8(val.c_str(), val.length(), true);
    }
    case coPoints:
        return perl_to_SV_clone_ref(static_cast<ConfigOptionPoints*>(opt)->get_at(i));
    case coBools:
        return newSViv(static_cast<ConfigOptionBools*>(opt)->get_at(i) ? 1 : 0);
    default:
        return &PL_sv_undef;
    }
}

bool ConfigBase__set(ConfigBase* THIS, const t_config_option_key &opt_key, SV* value)
{
    ConfigOption* opt = THIS->option(opt_key, true);
    if (opt == nullptr)
        CONFESS("Trying to set non-existing option");
    const ConfigOptionDef* def = THIS->def()->get(opt_key);
    if (opt->type() != def->type)
        CONFESS("Option type is different from the definition");
    switch (def->type) {
    case coFloat:
        if (!looks_like_number(value))
            return false;
        static_cast<ConfigOptionFloat*>(opt)->value = SvNV(value);
        break;
    case coFloats:
    {
        std::vector<double> &values = static_cast<ConfigOptionFloats*>(opt)->values;
        AV* av = (AV*)SvRV(value);
        const size_t len = av_len(av)+1;
        values.clear();
        values.reserve(len);
        for (size_t i = 0; i < len; ++ i) {
            SV** elem = av_fetch(av, i, 0);
            if (elem == NULL || !looks_like_number(*elem)) return false;
            values.emplace_back(SvNV(*elem));
        }
        break;
    }
    case coPercents:
    {
        std::vector<double> &values = static_cast<ConfigOptionPercents*>(opt)->values;
        AV* av = (AV*)SvRV(value);
        const size_t len = av_len(av)+1;
        values.clear();
        values.reserve(len);
        for (size_t i = 0; i < len; i++) {
            SV** elem = av_fetch(av, i, 0);
            if (elem == NULL || !looks_like_number(*elem)) return false;
            values.emplace_back(SvNV(*elem));
        }
        break;
    }
    case coInt:
        if (!looks_like_number(value)) return false;
        static_cast<ConfigOptionInt*>(opt)->value = SvIV(value);
        break;
    case coInts:
    {
        std::vector<int> &values = static_cast<ConfigOptionInts*>(opt)->values;
        AV* av = (AV*)SvRV(value);
        const size_t len = av_len(av)+1;
        values.clear();
        values.reserve(len);
        for (size_t i = 0; i < len; i++) {
            SV** elem = av_fetch(av, i, 0);
            if (elem == NULL || !looks_like_number(*elem)) return false;
            values.emplace_back(SvIV(*elem));
        }
        break;
    }
    case coString:
        static_cast<ConfigOptionString*>(opt)->value = std::string(SvPV_nolen(value), SvCUR(value));
        break;
    case coStrings:
    {
        std::vector<std::string> &values = static_cast<ConfigOptionStrings*>(opt)->values;
        AV* av = (AV*)SvRV(value);
        const size_t len = av_len(av)+1;
        values.clear();
        values.reserve(len);
        for (size_t i = 0; i < len; i++) {
            SV** elem = av_fetch(av, i, 0);
            if (elem == NULL) return false;
            values.emplace_back(std::string(SvPV_nolen(*elem), SvCUR(*elem)));
        }
        break;
    }
    case coPoint:
        return from_SV_check(value, &static_cast<ConfigOptionPoint*>(opt)->value);
    case coPoints:
    {
        std::vector<Pointf> &values = static_cast<ConfigOptionPoints*>(opt)->values;
        AV* av = (AV*)SvRV(value);
        const size_t len = av_len(av)+1;
        values.clear();
        values.reserve(len);
        for (size_t i = 0; i < len; i++) {
            SV** elem = av_fetch(av, i, 0);
            Pointf point;
            if (elem == NULL || !from_SV_check(*elem, &point)) return false;
            values.emplace_back(point);
        }
        break;
    }
    case coBool:
        static_cast<ConfigOptionBool*>(opt)->value = SvTRUE(value);
        break;
    case coBools:
    {
        std::vector<unsigned char> &values = static_cast<ConfigOptionBools*>(opt)->values;
        AV* av = (AV*)SvRV(value);
        const size_t len = av_len(av)+1;
        values.clear();
        values.reserve(len);
        for (size_t i = 0; i < len; i++) {
            SV** elem = av_fetch(av, i, 0);
            if (elem == NULL) return false;
            values.emplace_back(SvTRUE(*elem));
        }
        break;
    }
    default:
        if (! opt->deserialize(std::string(SvPV_nolen(value))))
            return false;
    }
    return true;
}

/* This method is implemented as a workaround for this typemap bug:
   https://rt.cpan.org/Public/Bug/Display.html?id=94110 */
bool ConfigBase__set_deserialize(ConfigBase* THIS, const t_config_option_key &opt_key, SV* str)
{
    size_t len;
    const char * c = SvPV(str, len);
    std::string value(c, len);
    return THIS->set_deserialize(opt_key, value);
}

void ConfigBase__set_ifndef(ConfigBase* THIS, const t_config_option_key &opt_key, SV* value, bool deserialize)
{
    if (THIS->has(opt_key))
        return;
    if (deserialize)
        ConfigBase__set_deserialize(THIS, opt_key, value);
    else
        ConfigBase__set(THIS, opt_key, value);
}

bool StaticConfig__set(StaticConfig* THIS, const t_config_option_key &opt_key, SV* value)
{
    const ConfigOptionDef* optdef = THIS->def()->get(opt_key);
    if (optdef->shortcut.empty())
        return ConfigBase__set(THIS, opt_key, value);
    for (const t_config_option_key &key : optdef->shortcut)
        if (! StaticConfig__set(THIS, key, value))
            return false;
    return true;
}

SV* to_AV(ExPolygon* expolygon)
{
    const unsigned int num_holes = expolygon->holes.size();
    AV* av = newAV();
    av_extend(av, num_holes);  // -1 +1
    
    av_store(av, 0, perl_to_SV_ref(expolygon->contour));
    
    for (unsigned int i = 0; i < num_holes; i++) {
        av_store(av, i+1, perl_to_SV_ref(expolygon->holes[i]));
    }
    return newRV_noinc((SV*)av);
}

SV* to_SV_pureperl(const ExPolygon* expolygon)
{
    const unsigned int num_holes = expolygon->holes.size();
    AV* av = newAV();
    av_extend(av, num_holes);  // -1 +1
    av_store(av, 0, to_SV_pureperl(&expolygon->contour));
    for (unsigned int i = 0; i < num_holes; i++) {
        av_store(av, i+1, to_SV_pureperl(&expolygon->holes[i]));
    }
    return newRV_noinc((SV*)av);
}

void from_SV(SV* expoly_sv, ExPolygon* expolygon)
{
    AV* expoly_av = (AV*)SvRV(expoly_sv);
    const unsigned int num_polygons = av_len(expoly_av)+1;
    expolygon->holes.resize(num_polygons-1);
    
    SV** polygon_sv = av_fetch(expoly_av, 0, 0);
    from_SV(*polygon_sv, &expolygon->contour);
    for (unsigned int i = 0; i < num_polygons-1; i++) {
        polygon_sv = av_fetch(expoly_av, i+1, 0);
        from_SV(*polygon_sv, &expolygon->holes[i]);
    }
}

void from_SV_check(SV* expoly_sv, ExPolygon* expolygon)
{
    if (sv_isobject(expoly_sv) && (SvTYPE(SvRV(expoly_sv)) == SVt_PVMG)) {
        if (!sv_isa(expoly_sv, perl_class_name(expolygon)) && !sv_isa(expoly_sv, perl_class_name_ref(expolygon)))
          CONFESS("Not a valid %s object", perl_class_name(expolygon));
        // a XS ExPolygon was supplied
        *expolygon = *(ExPolygon *)SvIV((SV*)SvRV( expoly_sv ));
    } else {
        // a Perl arrayref was supplied
        from_SV(expoly_sv, expolygon);
    }
}

void from_SV(SV* line_sv, Line* THIS)
{
    AV* line_av = (AV*)SvRV(line_sv);
    from_SV_check(*av_fetch(line_av, 0, 0), &THIS->a);
    from_SV_check(*av_fetch(line_av, 1, 0), &THIS->b);
}

void from_SV_check(SV* line_sv, Line* THIS)
{
    if (sv_isobject(line_sv) && (SvTYPE(SvRV(line_sv)) == SVt_PVMG)) {
        if (!sv_isa(line_sv, perl_class_name(THIS)) && !sv_isa(line_sv, perl_class_name_ref(THIS)))
            CONFESS("Not a valid %s object", perl_class_name(THIS));
        *THIS = *(Line*)SvIV((SV*)SvRV( line_sv ));
    } else {
        from_SV(line_sv, THIS);
    }
}

SV* to_AV(Line* THIS)
{
    AV* av = newAV();
    av_extend(av, 1);
    
    av_store(av, 0, perl_to_SV_ref(THIS->a));
    av_store(av, 1, perl_to_SV_ref(THIS->b));
    
    return newRV_noinc((SV*)av);
}

SV* to_SV_pureperl(const Line* THIS)
{
    AV* av = newAV();
    av_extend(av, 1);
    av_store(av, 0, to_SV_pureperl(&THIS->a));
    av_store(av, 1, to_SV_pureperl(&THIS->b));
    return newRV_noinc((SV*)av);
}

void from_SV(SV* poly_sv, MultiPoint* THIS)
{
    AV* poly_av = (AV*)SvRV(poly_sv);
    const unsigned int num_points = av_len(poly_av)+1;
    THIS->points.resize(num_points);
    
    for (unsigned int i = 0; i < num_points; i++) {
        SV** point_sv = av_fetch(poly_av, i, 0);
        from_SV_check(*point_sv, &THIS->points[i]);
    }
}

void from_SV_check(SV* poly_sv, MultiPoint* THIS)
{
    if (sv_isobject(poly_sv) && (SvTYPE(SvRV(poly_sv)) == SVt_PVMG)) {
        *THIS = *(MultiPoint*)SvIV((SV*)SvRV( poly_sv ));
    } else {
        from_SV(poly_sv, THIS);
    }
}

SV* to_AV(MultiPoint* THIS)
{
    const unsigned int num_points = THIS->points.size();
    AV* av = newAV();
    if (num_points > 0) av_extend(av, num_points-1);
    for (unsigned int i = 0; i < num_points; i++) {
        av_store(av, i, perl_to_SV_ref(THIS->points[i]));
    }
    return newRV_noinc((SV*)av);
}

SV* to_SV_pureperl(const MultiPoint* THIS)
{
    const unsigned int num_points = THIS->points.size();
    AV* av = newAV();
    if (num_points > 0) av_extend(av, num_points-1);
    for (unsigned int i = 0; i < num_points; i++) {
        av_store(av, i, to_SV_pureperl(&THIS->points[i]));
    }
    return newRV_noinc((SV*)av);
}

void from_SV_check(SV* poly_sv, Polygon* THIS)
{
    if (sv_isobject(poly_sv) && !sv_isa(poly_sv, perl_class_name(THIS)) && !sv_isa(poly_sv, perl_class_name_ref(THIS)))
        CONFESS("Not a valid %s object", perl_class_name(THIS));
    
    from_SV_check(poly_sv, (MultiPoint*)THIS);
}

void from_SV_check(SV* poly_sv, Polyline* THIS)
{
    if (!sv_isa(poly_sv, perl_class_name(THIS)) && !sv_isa(poly_sv, perl_class_name_ref(THIS)))
        CONFESS("Not a valid %s object", perl_class_name(THIS));
    
    from_SV_check(poly_sv, (MultiPoint*)THIS);
}

SV* to_SV_pureperl(const Point* THIS)
{
    AV* av = newAV();
    av_fill(av, 1);
    av_store(av, 0, newSViv(THIS->x));
    av_store(av, 1, newSViv(THIS->y));
    return newRV_noinc((SV*)av);
}

void from_SV(SV* point_sv, Point* point)
{
    AV* point_av = (AV*)SvRV(point_sv);
    // get a double from Perl and round it, otherwise
    // it would get truncated
    point->x = lrint(SvNV(*av_fetch(point_av, 0, 0)));
    point->y = lrint(SvNV(*av_fetch(point_av, 1, 0)));
}

void from_SV_check(SV* point_sv, Point* point)
{
    if (sv_isobject(point_sv) && (SvTYPE(SvRV(point_sv)) == SVt_PVMG)) {
        if (!sv_isa(point_sv, perl_class_name(point)) && !sv_isa(point_sv, perl_class_name_ref(point)))
            CONFESS("Not a valid %s object (got %s)", perl_class_name(point), HvNAME(SvSTASH(SvRV(point_sv))));
        *point = *(Point*)SvIV((SV*)SvRV( point_sv ));
    } else {
        from_SV(point_sv, point);
    }
}

SV* to_SV_pureperl(const Pointf* point)
{
    AV* av = newAV();
    av_fill(av, 1);
    av_store(av, 0, newSVnv(point->x));
    av_store(av, 1, newSVnv(point->y));
    return newRV_noinc((SV*)av);
}

bool from_SV(SV* point_sv, Pointf* point)
{
    AV* point_av = (AV*)SvRV(point_sv);
    SV* sv_x = *av_fetch(point_av, 0, 0);
    SV* sv_y = *av_fetch(point_av, 1, 0);
    if (!looks_like_number(sv_x) || !looks_like_number(sv_y)) return false;
    
    point->x = SvNV(sv_x);
    point->y = SvNV(sv_y);
    return true;
}

bool from_SV_check(SV* point_sv, Pointf* point)
{
    if (sv_isobject(point_sv) && (SvTYPE(SvRV(point_sv)) == SVt_PVMG)) {
        if (!sv_isa(point_sv, perl_class_name(point)) && !sv_isa(point_sv, perl_class_name_ref(point)))
            CONFESS("Not a valid %s object (got %s)", perl_class_name(point), HvNAME(SvSTASH(SvRV(point_sv))));
        *point = *(Pointf*)SvIV((SV*)SvRV( point_sv ));
        return true;
    } else {
        return from_SV(point_sv, point);
    }
}

void from_SV_check(SV* surface_sv, Surface* THIS)
{
    if (!sv_isa(surface_sv, perl_class_name(THIS)) && !sv_isa(surface_sv, perl_class_name_ref(THIS)))
        CONFESS("Not a valid %s object", perl_class_name(THIS));
    // a XS Surface was supplied
    *THIS = *(Surface *)SvIV((SV*)SvRV( surface_sv ));
}

SV* to_SV(TriangleMesh* THIS)
{
    SV* sv = newSV(0);
    sv_setref_pv( sv, perl_class_name(THIS), (void*)THIS );
    return sv;
}

}
#endif