#ifndef DELTALAKE_GOLANG_H
#define DELTALAKE_GOLANG_H

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

#ifdef __cplusplus
extern "C" {
#endif

// Forward declarations
typedef struct DeltaGoError DeltaGoError;
typedef struct DeltaTableHandle DeltaTableHandle;

// Result types for different return values
typedef struct {
    bool success;
    DeltaTableHandle* value;
    DeltaGoError* error;
} CResult_TableHandle;

typedef struct {
    bool success;
    char* value;
    DeltaGoError* error;
} CResult_String;

typedef struct {
    bool success;
    int64_t value;
    DeltaGoError* error;
} CResult_Long;

typedef struct {
    bool success;
    bool value;
    DeltaGoError* error;
} CResult_Bool;

typedef struct {
    bool success;
    void* value;
    DeltaGoError* error;
} CResult_Void;

// Core library functions
void deltalake_init(void);
const char* deltalake_version(void);

// Table operations
CResult_TableHandle deltalake_create_table(
    const char* table_path,
    const char* save_mode,
    const char* columns_json,
    const char* partition_columns_json,
    const char* table_name,
    const char* storage_options_json
);
);

void deltalake_open_table(
    const char* table_uri,
    int version,
    const char* storage_options,
    CResult_TableHandle* result
);

void deltalake_is_delta_table(
    const char* table_uri,
    const char* storage_options,
    CResult_Bool* result
);

void deltalake_table_free(DeltaTableHandle* handle);

void deltalake_table_uri(
    const DeltaTableHandle* handle,
    CResult_String* result
);

void deltalake_table_version(
    const DeltaTableHandle* handle,
    CResult_Long* result
);

void deltalake_table_schema_json(
    const DeltaTableHandle* handle,
    CResult_String* result
);

void deltalake_table_files(
    const DeltaTableHandle* handle,
    const char* partition_filters,
    char*** files,
    int* files_len,
    CResult_Void* result
);

void deltalake_free_files(char** files, int files_len);

void deltalake_table_reload(
    const DeltaTableHandle* handle,
    CResult_Void* result
);

void deltalake_table_metadata_json(
    const DeltaTableHandle* handle,
    CResult_String* result
);

// Schema operations
void deltalake_schema_validate_json(
    const char* schema_json,
    CResult_Bool* result
);

void deltalake_schema_arrow_to_delta(
    const char* arrow_schema_json,
    CResult_String* result
);

void deltalake_schema_field_names(
    const char* schema_json,
    char*** field_names,
    int* field_names_len,
    CResult_Void* result
);

void deltalake_free_field_names(char** field_names, int field_names_len);

// Writer operations
void deltalake_write_parquet_files(
    const DeltaTableHandle* handle,
    const char* const* parquet_files,
    int parquet_files_len,
    const char* mode,
    const char* const* partition_columns,
    int partition_columns_len,
    CResult_Void* result
);

void deltalake_insert_sample_data(
    const DeltaTableHandle* handle,
    CResult_Void* result
);

void deltalake_optimize_table(
    const DeltaTableHandle* handle,
    int64_t target_size,
    CResult_String* result
);

void deltalake_vacuum_table(
    const DeltaTableHandle* handle,
    int64_t retention_hours,
    bool dry_run,
    CResult_String* result
);

// Filesystem operations
void deltalake_list_files(
    const char* table_uri,
    const char* storage_options,
    CResult_String* result
);

void deltalake_table_stats(
    const char* table_uri,
    const char* storage_options,
    CResult_String* result
);

// Vacuum operations
typedef struct VacuumResult {
    void* table_handle;
    char* metrics_json;
} VacuumResult;

void* deltalake_vacuum_table(const void* table_handle);
void deltalake_vacuum_set_retention_hours(void* vacuum_handle, int hours);
void deltalake_vacuum_set_dry_run(void* vacuum_handle, int dry_run);
VacuumResult* deltalake_vacuum_execute(void* vacuum_handle);
void deltalake_free_vacuum_builder(void* vacuum_handle);
void deltalake_free_vacuum_result(VacuumResult* result);

// Memory management
void deltalake_free_string(char* ptr);
void deltalake_free_error(DeltaGoError* error);

// Error handling
const char* deltalake_error_message(const DeltaGoError* error);
int deltalake_error_type(const DeltaGoError* error);

#ifdef __cplusplus
}
#endif

#endif // DELTALAKE_GOLANG_H