#ifndef SRT_INTEROP_H
#define SRT_INTEROP_H

#include <stdint.h>
#include <stdbool.h>

#ifdef _WIN32
  #ifdef SRT_INTEROP_BUILD
    #define SRT_API __declspec(dllexport)
  #else
    #define SRT_API __declspec(dllimport)
  #endif
#else
  #define SRT_API
#endif

#ifdef __cplusplus
extern "C" {
#endif

typedef struct srt_scene_t srt_scene_t;

typedef enum srt_result_e
{
    SRT_OK = 0,
    SRT_ERROR = 1,
    SRT_INVALID_ARGUMENT = 2,
    SRT_OUT_OF_RANGE = 3,
    SRT_OUT_OF_CAPACITY = 4,
    SRT_NOT_FOUND = 5,
} srt_result_e;

typedef struct srt_vec2_t
{
    float x;
    float y;
} srt_vec2_t;

typedef struct srt_vec3_t
{
    float x;
    float y;
    float z;
} srt_vec3_t;

typedef struct srt_quat_t
{
    float x;
    float y;
    float z;
    float w;
} srt_quat_t;

typedef struct srt_mat4_t
{
    float m[16];
} srt_mat4_t;

/* Camera params: setter recomputes derived fields (fov, size_y) */
typedef struct srt_camera_params_t
{
    srt_vec3_t position;
    srt_quat_t rotation;

    float focal_length;
    float size_x;
    float aspect_ratio;
} srt_camera_params_t;

/* Lights */
typedef enum srt_punctual_light_type_e
{
    SRT_LIGHT_TYPE_POINT = 0,
    SRT_LIGHT_TYPE_SPOT = 1,
    SRT_LIGHT_TYPE_AREA = 2,
} srt_punctual_light_type_e;

typedef struct srt_punctual_light_t
{
    srt_vec3_t position;
    srt_vec3_t color;
    float intensity;
    uint32_t type; /* srt_punctual_light_type_e */
} srt_punctual_light_t;

typedef struct srt_directional_light_t
{
    srt_vec3_t direction;
    srt_vec3_t color;
    float intensity;
    float angular_diameter;
} srt_directional_light_t;

/* Textures/materials */
typedef struct srt_texture_handle_t
{
    uint32_t id;
    uint32_t generation;
} srt_texture_handle_t;

typedef enum srt_texture_wrap_mode_e
{
    SRT_TEX_WRAP_REPEAT = 0,
    SRT_TEX_WRAP_CLAMP = 1,
} srt_texture_wrap_mode_e;

typedef enum srt_texture_filter_mode_e
{
    SRT_TEX_FILTER_NEAREST = 0,
    SRT_TEX_FILTER_LINEAR = 1,
} srt_texture_filter_mode_e;

typedef enum srt_texture_stride_e
{
    SRT_TEX_STRIDE_UINT8 = 1,
    SRT_TEX_STRIDE_UINT16 = 2,
    SRT_TEX_STRIDE_FLOAT32 = 4,
} srt_texture_stride_e;

typedef struct srt_material_handle_t
{
    uint8_t id;
} srt_material_handle_t;

typedef struct srt_standard_lit_properties_t
{
    srt_vec3_t albedo;
    float diffuse_roughness;
    float roughness;
    float metallic;

    srt_texture_handle_t albedo_texture;
    srt_texture_handle_t normal_texture;
    srt_texture_handle_t roughness_texture;
    srt_texture_handle_t metallic_texture;
} srt_standard_lit_properties_t;

/* Mesh editing */
typedef struct srt_vertex_t
{
    srt_vec3_t position;
    srt_vec3_t normal;
    srt_vec3_t tangent;
    srt_vec3_t color;
    srt_vec2_t uv;
} srt_vertex_t;

typedef struct srt_triangle_t
{
    srt_vertex_t v0;
    srt_vertex_t v1;
    srt_vertex_t v2;
    uint32_t material_id; /* stored as uint8_t internally */
} srt_triangle_t;

typedef struct srt_mesh_handle_t
{
    uint32_t model_id;
    uint32_t instance_id;

    uint64_t triangle_id;
    uint64_t triangle_count;
    uint16_t material_id;
    uint16_t material_count;
} srt_mesh_handle_t;

typedef struct srt_render_job_t srt_render_job_t;

/* Rendering (matches Rendering/Renderer.h) */
typedef enum srt_rendering_mode_e
{
    SRT_RENDER_PROGRESSIVE = 0,
    SRT_RENDER_TILE_BASED = 1,
} srt_rendering_mode_e;

typedef struct srt_rendering_config_t
{
    uint32_t width;
    uint32_t height;
    uint32_t sample_count;
    uint8_t max_depth;

    uint32_t bucket_size;
} srt_rendering_config_t;

/* AOV indices (matches Rendering/AOV.h) */
typedef enum srt_aov_index_e
{
    SRT_AOV_BEAUTY_INDEX = 0,
    SRT_AOV_ALBEDO_INDEX = 1,
    SRT_AOV_NORMAL_INDEX = 2,
    SRT_AOV_DEPTH_INDEX = 3,
    SRT_AOV_POSITION_INDEX = 4,
    SRT_AOV_DIRECT_INDEX = 5,
    SRT_AOV_INDIRECT_INDEX = 6,
} srt_aov_index_e;

typedef enum srt_aov_flags_e
{
    SRT_AOV_BEAUTY = 1u << 0,
    SRT_AOV_ALBEDO = 1u << 1,
    SRT_AOV_NORMAL = 1u << 2,
    SRT_AOV_DEPTH = 1u << 3,
    SRT_AOV_POSITION = 1u << 4,
    SRT_AOV_DIRECT = 1u << 5,
    SRT_AOV_INDIRECT = 1u << 6,
} srt_aov_flags_e;

typedef struct srt_float4_t
{
    float x;
    float y;
    float z;
    float w;
} srt_float4_t;

/* Scene lifecycle */
SRT_API srt_scene_t* srt_scene_create(uint64_t triangle_count,
                                      uint16_t texture_count,
                                      uint8_t material_count,
                                      uint32_t punctual_light_count);

SRT_API void srt_scene_destroy(srt_scene_t* scene);

/* Commit changes (rebuild TLAS/BVH when needed) */
SRT_API srt_result_e srt_scene_commit(srt_scene_t* scene);

/* Camera */
SRT_API srt_result_e srt_scene_camera_get(const srt_scene_t* scene, srt_camera_params_t* out_params);
SRT_API srt_result_e srt_scene_camera_set(srt_scene_t* scene, const srt_camera_params_t* params);

/* Lights (IDs are array indices; remove uses swap-remove, so IDs may change) */
SRT_API srt_result_e srt_scene_get_directional_light_count(const srt_scene_t* scene, uint32_t* out_count);
SRT_API srt_result_e srt_scene_get_directional_light(const srt_scene_t* scene, uint32_t id, srt_directional_light_t* out_light);
SRT_API srt_result_e srt_scene_add_directional_light(srt_scene_t* scene, const srt_directional_light_t* light, uint32_t* out_id);
SRT_API srt_result_e srt_scene_set_directional_light(srt_scene_t* scene, uint32_t id, const srt_directional_light_t* light);
SRT_API srt_result_e srt_scene_remove_directional_light(srt_scene_t* scene, uint32_t id);

SRT_API srt_result_e srt_scene_get_punctual_light_count(const srt_scene_t* scene, uint32_t* out_count);
SRT_API srt_result_e srt_scene_get_punctual_light(const srt_scene_t* scene, uint32_t id, srt_punctual_light_t* out_light);
SRT_API srt_result_e srt_scene_add_punctual_light(srt_scene_t* scene, const srt_punctual_light_t* light, uint32_t* out_id);
SRT_API srt_result_e srt_scene_set_punctual_light(srt_scene_t* scene, uint32_t id, const srt_punctual_light_t* light);
SRT_API srt_result_e srt_scene_remove_punctual_light(srt_scene_t* scene, uint32_t id);

/* Materials */
SRT_API srt_result_e srt_scene_get_material_count(const srt_scene_t* scene, uint32_t* out_count);
SRT_API srt_result_e srt_scene_get_material_emission(const srt_scene_t* scene, srt_material_handle_t mat, srt_vec3_t* out_emission);
SRT_API srt_result_e srt_scene_set_material_emission(srt_scene_t* scene, srt_material_handle_t mat, srt_vec3_t emission);

SRT_API srt_result_e srt_scene_get_material_properties_size(const srt_scene_t* scene, srt_material_handle_t mat, uint32_t* out_size);
SRT_API srt_result_e srt_scene_get_material_properties(const srt_scene_t* scene,
                                                       srt_material_handle_t mat,
                                                       void* out_properties,
                                                       uint32_t out_properties_size,
                                                       uint32_t* out_required_size);

SRT_API srt_result_e srt_scene_set_material_properties(srt_scene_t* scene, srt_material_handle_t mat, const void* properties, uint32_t properties_size);

SRT_API srt_result_e srt_scene_create_standard_lit_material(srt_scene_t* scene,
                                                            const srt_standard_lit_properties_t* props,
                                                            srt_vec3_t emission,
                                                            srt_material_handle_t* out_mat);

/* Textures */
SRT_API srt_result_e srt_scene_texture_load(srt_scene_t* scene,
                                           const char* filename,
                                           uint8_t srgb,
                                           uint8_t mipmap,
                                           uint32_t stride, /* srt_texture_stride_e */
                                           srt_texture_handle_t* out_texture);

SRT_API srt_result_e srt_scene_texture_set_sampler(srt_scene_t* scene,
                                                   srt_texture_handle_t texture,
                                                   uint32_t wrap_mode,  /* srt_texture_wrap_mode_e */
                                                   uint32_t filter_mode /* srt_texture_filter_mode_e */);

/* Sky */
typedef enum srt_sky_kind_e
{
    SRT_SKY_NONE = 0,
    SRT_SKY_CONSTANT = 1,
    SRT_SKY_HDR = 2,
} srt_sky_kind_e;

typedef struct srt_sky_desc_t
{
    uint32_t kind;      /* srt_sky_kind_e */
    uint32_t data_size; /* bytes at `data` */
    const void* data;   /* points to a kind-specific POD struct */
} srt_sky_desc_t;

typedef struct srt_sky_constant_desc_t
{
    srt_vec3_t color;
    float intensity;
} srt_sky_constant_desc_t;

typedef struct srt_sky_hdr_desc_t
{
    srt_texture_handle_t hdri;
    float intensity;
} srt_sky_hdr_desc_t;

/* Generic, extensible sky setter (preferred). */
SRT_API srt_result_e srt_scene_set_sky(srt_scene_t* scene, const srt_sky_desc_t* desc);

SRT_API srt_result_e srt_scene_set_sky_none(srt_scene_t* scene);
SRT_API srt_result_e srt_scene_set_sky_constant(srt_scene_t* scene, srt_vec3_t color, float intensity);
SRT_API srt_result_e srt_scene_set_sky_hdr(srt_scene_t* scene, srt_texture_handle_t hdri, float intensity);

/* Mesh loading (Assimp) */
SRT_API srt_result_e srt_scene_load_mesh(srt_scene_t* scene, const char* filename_utf8, srt_mesh_handle_t* out_mesh);

/* Procedural / editor meshes */
SRT_API srt_result_e srt_scene_add_mesh_model(srt_scene_t* scene, uint64_t triangle_reserve, uint32_t* out_model_id);
SRT_API srt_result_e srt_scene_remove_mesh_model(srt_scene_t* scene, uint32_t model_id);

SRT_API srt_result_e srt_scene_mesh_model_set_triangles(srt_scene_t* scene,
                                                        uint32_t model_id,
                                                        const srt_triangle_t* triangles,
                                                        uint32_t triangle_count);

SRT_API srt_result_e srt_scene_add_mesh_instance(srt_scene_t* scene, uint32_t model_id, const srt_mat4_t* local_to_world, uint32_t* out_instance_id);
SRT_API srt_result_e srt_scene_remove_mesh_instance(srt_scene_t* scene, uint32_t instance_id);
SRT_API srt_result_e srt_scene_set_mesh_instance_transform(srt_scene_t* scene, uint32_t instance_id, const srt_mat4_t* local_to_world);

/* Renderer job lifecycle */
SRT_API srt_result_e srt_render_job_create(srt_scene_t* scene,
                                                        const srt_rendering_config_t* config,
                                                        uint32_t aov_flags,
                                                        uint32_t rendering_mode,
                                                        uint32_t seed,
                                                        srt_render_job_t** out_job);

SRT_API void srt_render_job_destroy(srt_render_job_t* job);

/* Start rendering (blocking). Call from a background thread in C#. */
SRT_API srt_result_e srt_render_job_start(srt_render_job_t* job);

/* Cooperative stop: sets job->is_done so renderer loop exits. */
SRT_API void srt_render_job_request_stop(srt_render_job_t* job);

SRT_API srt_result_e srt_render_job_is_done(const srt_render_job_t* job, bool* out_done);

/* AOV buffer access (linear float4 buffer, width*height pixels) */
SRT_API srt_result_e srt_render_job_get_aov_desc(const srt_render_job_t* job,
                                                                 uint32_t aov_index,
                                                                 uint32_t* out_width,
                                                                 uint32_t* out_height,
                                                                 uint32_t* out_stride_bytes);

SRT_API const srt_float4_t* srt_render_job_get_aov_pixels(const srt_render_job_t* job, uint32_t aov_index);

/* Convert an AOV to BGRA8 for UI display (tone-map + gamma to match Window.c behavior).
    dst_stride_bytes must be >= width*4. */
SRT_API srt_result_e srt_render_job_copy_aov_bgra8(const srt_render_job_t* job,
                                                                    uint32_t aov_index,
                                                                    uint8_t* dst,
                                                                    uint32_t dst_stride_bytes);

#ifdef __cplusplus
}
#endif

#endif /* SRT_INTEROP_H */