%module{Slic3r::XS};

%{
#include <xsinit.h>
#include "libslic3r/Model.hpp"
#include "libslic3r/Print.hpp"
#include "libslic3r/PrintConfig.hpp"
#include "libslic3r/Slicing.hpp"
#include "libslic3r/Format/AMF.hpp"
#include "libslic3r/Format/3mf.hpp"
#include "libslic3r/Format/OBJ.hpp"
#include "libslic3r/Format/PRUS.hpp"
#include "libslic3r/Format/STL.hpp"
#include "slic3r/GUI/PresetBundle.hpp"
%}

%name{Slic3r::Model} class Model {
    Model();
    ~Model();

    %name{read_from_file} Model(std::string input_file, bool add_default_instances = true)
        %code%{
            try {
                RETVAL = new Model(Model::read_from_file(input_file, nullptr, add_default_instances));
            } catch (std::exception& e) {
                croak("Error while opening %s: %s\n", input_file.c_str(), e.what());
            }
        %};

    Clone<Model> clone()
        %code%{ RETVAL = THIS; %};
    
    %name{_add_object} Ref<ModelObject> add_object();
    Ref<ModelObject> _add_object_clone(ModelObject* other, bool copy_volumes = true)
        %code%{ RETVAL = THIS->add_object(*other, copy_volumes); %};
    void delete_object(size_t idx);
    void clear_objects();
    size_t objects_count()
        %code%{ RETVAL = THIS->objects.size(); %};
    Ref<ModelObject> get_object(int idx)
        %code%{ RETVAL = THIS->objects.at(idx); %};

    Ref<ModelMaterial> get_material(t_model_material_id material_id)
        %code%{
            RETVAL = THIS->get_material(material_id);
            if (RETVAL == NULL) {
                XSRETURN_UNDEF;
            }
        %};

    %name{add_material} Ref<ModelMaterial> add_material(t_model_material_id material_id);
    Ref<ModelMaterial> add_material_clone(t_model_material_id material_id, ModelMaterial* other)
        %code%{ RETVAL = THIS->add_material(material_id, *other); %};
    bool has_material(t_model_material_id material_id) const
        %code%{
            RETVAL = (THIS->get_material(material_id) != NULL);
        %};
    void delete_material(t_model_material_id material_id);
    void clear_materials();

    std::vector<std::string> material_names() const
        %code%{
            for (ModelMaterialMap::iterator i = THIS->materials.begin();
                i != THIS->materials.end(); ++i)
            {
                RETVAL.push_back(i->first);
            }
        %};

    size_t material_count() const
        %code%{ RETVAL = THIS->materials.size(); %};

    bool add_default_instances();
    Clone<BoundingBoxf3> bounding_box();
    void center_instances_around_point(Vec2d* point)
        %code%{ THIS->center_instances_around_point(*point); %};
    void translate(double x, double y, double z);
    Clone<TriangleMesh> mesh();

    ModelObjectPtrs* objects()
        %code%{ RETVAL = &THIS->objects; %};
    
    bool arrange_objects(double dist, BoundingBoxf* bb = NULL);
    void duplicate(unsigned int copies_num, double dist, BoundingBoxf* bb = NULL);
    void duplicate_objects(unsigned int copies_num, double dist, BoundingBoxf* bb = NULL);
    void duplicate_objects_grid(unsigned int x, unsigned int y, double dist);

    bool looks_like_multipart_object() const;
    void convert_multipart_object(unsigned int max_extruders);

    void print_info() const;

    bool store_stl(char *path, bool binary)
        %code%{ TriangleMesh mesh = THIS->mesh(); RETVAL = Slic3r::store_stl(path, &mesh, binary); %};
    bool store_amf(char *path, Print* print, bool export_print_config)
        %code%{ RETVAL = Slic3r::store_amf(path, THIS, print, export_print_config); %};
    bool store_3mf(char *path, Print* print, bool export_print_config)
        %code%{ RETVAL = Slic3r::store_3mf(path, THIS, print, export_print_config); %};

%{

Model*
load_stl(CLASS, path, object_name)
    char*           CLASS;
    char*           path;
    char*           object_name;
    CODE:
        RETVAL = new Model();
        if (! load_stl(path, RETVAL, object_name)) {
            delete RETVAL;
            RETVAL = NULL;
        }
    OUTPUT:
        RETVAL

%}
};

%name{Slic3r::Model::Material} class ModelMaterial {
    Ref<Model> model()
        %code%{ RETVAL = THIS->get_model(); %};

    Ref<DynamicPrintConfig> config()
        %code%{ RETVAL = &THIS->config; %};
    
    std::string get_attribute(std::string name)
        %code%{ if (THIS->attributes.find(name) != THIS->attributes.end()) RETVAL = THIS->attributes[name]; %};
    
    void set_attribute(std::string name, std::string value)
        %code%{ THIS->attributes[name] = value; %};

%{

SV*
ModelMaterial::attributes()
    CODE:
        HV* hv = newHV();
        for (t_model_material_attributes::const_iterator attr = THIS->attributes.begin(); attr != THIS->attributes.end(); ++attr) {
            (void)hv_store( hv, attr->first.c_str(), attr->first.length(), newSVpv(attr->second.c_str(), attr->second.length()), 0 );
        }
        RETVAL = (SV*)newRV_noinc((SV*)hv);
    OUTPUT:
        RETVAL
%}

};


%name{Slic3r::Model::Object} class ModelObject {
    ModelVolumePtrs* volumes()
        %code%{ RETVAL = &THIS->volumes; %};

    ModelInstancePtrs* instances()
        %code%{ RETVAL = &THIS->instances; %};
    
    void invalidate_bounding_box();
    Clone<TriangleMesh> mesh();
    Clone<TriangleMesh> raw_mesh();
    Clone<BoundingBoxf3> instance_bounding_box(int idx)
        %code%{ RETVAL = THIS->instance_bounding_box(idx, true); %};
    Clone<BoundingBoxf3> bounding_box();

    %name{_add_volume} Ref<ModelVolume> add_volume(TriangleMesh* mesh)
        %code%{ RETVAL = THIS->add_volume(*mesh); %};
    Ref<ModelVolume> _add_volume_clone(ModelVolume* other)
        %code%{ RETVAL = THIS->add_volume(*other); %};

    void delete_volume(size_t idx);
    void clear_volumes();
    int volumes_count()
        %code%{ RETVAL = THIS->volumes.size(); %};
    Ref<ModelVolume> get_volume(int idx)
        %code%{ RETVAL = THIS->volumes.at(idx); %};
    bool move_volume_up(int idx)
        %code%{ 
            if (idx > 0 && idx < int(THIS->volumes.size())) {
                std::swap(THIS->volumes[idx-1], THIS->volumes[idx]);
                RETVAL = true;
            } else
                RETVAL = false;
        %};
    bool move_volume_down(int idx)
        %code%{ 
            if (idx >= 0 && idx + 1 < int(THIS->volumes.size())) {
                std::swap(THIS->volumes[idx+1], THIS->volumes[idx]);
                RETVAL = true;
            } else
                RETVAL = false;
        %};

    %name{_add_instance} Ref<ModelInstance> add_instance();
    Ref<ModelInstance> _add_instance_clone(ModelInstance* other)
        %code%{ RETVAL = THIS->add_instance(*other); %};
    void delete_last_instance();
    void clear_instances();
    int instances_count()
        %code%{ RETVAL = THIS->instances.size(); %};

    std::string name()
        %code%{ RETVAL = THIS->name; %};
    void set_name(std::string value)
        %code%{ THIS->name = value; %};
    std::string input_file()
        %code%{ RETVAL = THIS->input_file; %};
    void set_input_file(std::string value)
        %code%{ THIS->input_file = value; %};
    Ref<DynamicPrintConfig> config()
        %code%{ RETVAL = &THIS->config; %};

    Ref<Model> model()
        %code%{ RETVAL = THIS->get_model(); %};

    t_layer_height_ranges layer_height_ranges()
        %code%{ RETVAL = THIS->layer_height_ranges; %};
    void set_layer_height_ranges(t_layer_height_ranges ranges)
        %code%{ THIS->layer_height_ranges = ranges; %};

    std::vector<double> layer_height_profile() 
        %code%{ RETVAL = THIS->layer_height_profile_valid ? THIS->layer_height_profile : std::vector<double>(); %};
    void set_layer_height_profile(std::vector<double> profile)
        %code%{ THIS->layer_height_profile = profile; THIS->layer_height_profile_valid = true; %};

    Ref<Vec3d> origin_translation()
        %code%{ RETVAL = &THIS->origin_translation; %};
    void set_origin_translation(Vec3d* point)
        %code%{ THIS->origin_translation = *point; %};
    
    bool needed_repair() const;
    int materials_count() const;
    int facets_count();
    void center_around_origin();
    void translate(double x, double y, double z);
    void scale_xyz(Vec3d* versor)
        %code{% THIS->scale(*versor); %};
    void rotate(float angle, Vec3d* axis)
        %code{% THIS->rotate(angle, *axis); %};
    void mirror(Axis axis);
    
    Model* cut(double z)
        %code%{
            RETVAL = new Model();
            THIS->cut(z, RETVAL);
        %};

    ModelObjectPtrs* split_object()
        %code%{
            RETVAL = new ModelObjectPtrs();  // leak?
            THIS->split(RETVAL);
        %};

    void print_info() const;
};


%name{Slic3r::Model::Volume} class ModelVolume {
    Ref<ModelObject> object()
        %code%{ RETVAL = THIS->get_object(); %};
    
    std::string name()
        %code%{ RETVAL = THIS->name; %};
    void set_name(std::string value)
        %code%{ THIS->name = value; %};
    t_model_material_id material_id();
    void set_material_id(t_model_material_id material_id)
        %code%{ THIS->material_id(material_id); %};
    Ref<ModelMaterial> material();
    
    Ref<DynamicPrintConfig> config()
        %code%{ RETVAL = &THIS->config; %};
    Ref<TriangleMesh> mesh()
        %code%{ RETVAL = &THIS->mesh; %};
    
    bool modifier()
        %code%{ RETVAL = THIS->is_modifier(); %};
    void set_modifier(bool modifier)
        %code%{ THIS->set_type(modifier ? ModelVolume::PARAMETER_MODIFIER : ModelVolume::MODEL_PART); %};
    bool model_part()
        %code%{ RETVAL = THIS->is_model_part(); %};
    bool support_enforcer()
        %code%{ RETVAL = THIS->is_support_enforcer(); %};
    void set_support_enforcer()
        %code%{ THIS->set_type(ModelVolume::SUPPORT_ENFORCER); %};
    bool support_blocker()
        %code%{ RETVAL = THIS->is_support_blocker(); %};
    void set_support_blocker()
        %code%{ THIS->set_type(ModelVolume::SUPPORT_BLOCKER); %};

    size_t split(unsigned int max_extruders);
    
    ModelMaterial* assign_unique_material();
};


%name{Slic3r::Model::Instance} class ModelInstance {
    Ref<ModelObject> object()
        %code%{ RETVAL = THIS->get_object(); %};

    Vec3d* rotation()
        %code%{ RETVAL = new Vec3d(THIS->get_rotation(X), THIS->get_rotation(Y), THIS->get_rotation(Z)); %};
        
    Vec3d* scaling_factor()
        %code%{ RETVAL = new Vec3d(THIS->get_scaling_factor(X), THIS->get_scaling_factor(Y), THIS->get_scaling_factor(Z)); %};
        
    Vec2d* offset()
        %code%{ RETVAL = new Vec2d(THIS->get_offset(X), THIS->get_offset(Y)); %};
        
    void set_rotation(double val)
        %code%{ THIS->set_rotation(Z, val); THIS->get_object()->invalidate_bounding_box(); %};
        
    void set_rotations(Vec3d *rotation)
        %code%{ THIS->set_rotation(*rotation); THIS->get_object()->invalidate_bounding_box(); %};
        
    void set_scaling_factor(double val)
        %code%{ THIS->set_scaling_factor(X, val); THIS->set_scaling_factor(Y, val); THIS->set_scaling_factor(Z, val); THIS->get_object()->invalidate_bounding_box(); %};
        
    void set_scaling_factors(Vec3d *scale)
        %code%{ THIS->set_scaling_factor(*scale); THIS->get_object()->invalidate_bounding_box(); %};
        
    void set_offset(Vec2d *offset)
        %code%{ 
            THIS->set_offset(X, (*offset)(0));
            THIS->set_offset(Y, (*offset)(1));
        %};

    void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const;
    void transform_polygon(Polygon* polygon) const;
};