#include "./firebird/ibase.h"
#include "./firebird/ib_util.h"

#ifdef FBUDF_EXPORTS
# ifdef __WINNT__
#   define FBUDF_API __declspec(dllexport) __cdecl
# else
#   define FBUDF_API __declspec(dllexport) __cdecl
# endif
#else
# ifdef __WINNT__
#   define FBUDF_API __cdecl
# else
#   define FBUDF_API __cdecl
# endif
#endif


typedef struct IB_BLOB {
    short __cdecl (* blob_get_segment)
        (
          void*       hnd,
          void*       buffer,
          ISC_USHORT  buf_size,
          ISC_USHORT  *result_len
        );
    void*		blob_handle;
    ISC_LONG	blob_number_segments;
    ISC_LONG	blob_max_segment;
    ISC_LONG	blob_total_length;
    void __cdecl (* blob_put_segment)
        (
          void*       hnd,
          const void* buffer,
          ISC_USHORT  buf_size
        );
    ISC_LONG __cdecl (* blob_lseek)
        (
          void* hnd,
          ISC_USHORT mode,
          ISC_LONG offset
        );
}  *LPIB_BLOB;

#define max_blob_segment_size 2048

#ifdef __cplusplus
extern "C" {
#endif

  DWORD FBUDF_API raw_init
      (
        DWORD * Mode,
        const DWORD * Handle
      );
  DWORD FBUDF_API raw_addblob
      (
        DWORD * Handle,
        const IB_BLOB* BLOb
      );
  DWORD FBUDF_API raw_add
      (
        DWORD * Handle,
        DWORD * Mode,
        const PARAMDSC* Param
      );
  DWORD FBUDF_API raw_rewrite
      (
        DWORD * Handle,
        __INT64 * Offset,
        const PARAMDSC* Param
      );
  DWORD FBUDF_API raw_free(DWORD * Handle);
  void  FBUDF_API raw_get
      (
        DWORD * Handle,
        DWORD * Mode,
        const IB_BLOB* BLOb
      );

#ifdef __cplusplus
}
#endif

DWORD FBUDF_API raw_addblob(DWORD * Handle, const IB_BLOB* BLOb)
{
  DWORD result = false;
  my::CBuffer* raw = NULL;

  if (!(*Handle)
      || BLOb == NULL
      || BLOb->blob_handle == NULL
      || !BLOb->blob_total_length > 0)
    return result;

  my::CThreadContext* thread_context = my::get_thread_context();
  if (thread_context != NULL)
    raw = thread_context->getBuffers()->get(*Handle);

  if (raw != NULL)
  {
    void* buff = NULL;
    ISC_USHORT buff_size;
    if (!BLOb->blob_max_segment
        || BLOb->blob_max_segment > max_blob_segment_size)
      buff_size = max_blob_segment_size;
    else
      buff_size = BLOb->blob_max_segment;
    if (BLOb->blob_handle != NULL && buff_size)
      buff = ::malloc(buff_size);
    if (buff != NULL)
    {
      result++;
      ISC_USHORT length = 0;
      try
      {
        while ((*BLOb->blob_get_segment)
            (
              BLOb->blob_handle,
              buff,
              buff_size,
              &length
            ))
        {
          if (length)
            raw->add(buff, length);
          else
            break;
          length = 0;
        }
      }
      catch (...)
      {
        result = false;
      }
      ::free(buff);
    } // if (buff != NULL)
  }
  return result;
}

void FBUDF_API raw_get(DWORD * Handle, DWORD * Mode, const IB_BLOB* BLOb)
{
  DWORD result = false;
  DWORD mode = *Mode;
  DWORD free_mask = 1;
  my::CThreadContext * volatile thread_context = NULL;
  my::CThreadBuffers* buffs = NULL;
  my::CBuffer* raw = NULL;
  ISC_USHORT segment_size;

  thread_context = my::get_thread_context();
  if (thread_context != NULL
      && (*Handle)
      && BLOb != NULL && BLOb->blob_handle != NULL)
  {
    buffs = thread_context->getBuffers();
    if (buffs != NULL) raw = buffs->get(*Handle);

      if (!BLOb->blob_max_segment
        || BLOb->blob_max_segment > max_blob_segment_size)
      segment_size = max_blob_segment_size;
    else
      segment_size = BLOb->blob_max_segment;

    if (raw != NULL)
    {
      __INT64 buff_size = raw->size();
      if (buff_size)
      {
        void* buff = NULL;
        buff = ::malloc(buff_size);
        ::size_t length = raw->get(buff, buff_size);
        if (mode & 0x80000000)
        {
          mode = (~mode); mode++;
          if (mode & (~free_mask) == 64)
          {
            // -- decode Base64 to bin
            void* dst_buff = my::base64_decode
                (
                  reinterpret_cast<const char*>(buff),
                  &length
                );
            ::free(buff);
            buff = dst_buff;
          }
        }
        else
          if (mode & (~free_mask) == 64)
          {
            // -- encode bin to Base64
            char* dst_buff = my::base64_encode(buff, length);
            ::free(buff);
            buff = dst_buff;
            length = ::strlen(dst_buff);
          }
        char*      ptr = reinterpret_cast<char*>(buff);
        ISC_USHORT len = segment_size;
        if (length)
        {
          while (length > segment_size)
          {
            (*BLOb->blob_put_segment)(BLOb->blob_handle, ptr, len);
            ptr += len;
            length -= len;
          }
          len = length;
          (*BLOb->blob_put_segment)(BLOb->blob_handle, ptr, len);
        } // if (length)
        if (buff != NULL) ::free(buff);
      } // if (buff_size)
      if (mode & free_mask) ::free(raw);
      result++;
    } // if (raw != NULL)
  }
}

DECLARE EXTERNAL FUNCTION RAW_INIT
  INTEGER,
  INTEGER
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_init' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_FREE
  INTEGER
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_free' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_ADD_INT16
  INTEGER,
  INTEGER,
  SMALLINT BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_add' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_ADD_INT32
  INTEGER,
  INTEGER,
  INTEGER BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_add' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_ADD_INT64
  INTEGER,
  INTEGER,
  BIGINT BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_add' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_ADD_CHAR
  INTEGER,
  INTEGER,
  CHAR(766) BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_add' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_ADD_CSTR
  INTEGER,
  INTEGER,
  CSTRING(766) BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_add' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_ADD_VCHAR
  INTEGER,
  INTEGER,
  VARCHAR(32765) BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_add' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_ADD_BLOB
  INTEGER,
  BLOB
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_addblob' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_REWRITE_INT16
  INTEGER,
  BIGINT,
  SMALLINT BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_rewrite' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_REWRITE_INT32
  INTEGER,
  BIGINT,
  INTEGER BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_rewrite' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_REWRITE_INT64
  INTEGER,
  BIGINT,
  BIGINT BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_rewrite' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_REWRITE_CHAR
  INTEGER,
  BIGINT,
  CHAR(766) BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_rewrite' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_REWRITE_CSTR
  INTEGER,
  BIGINT,
  CSTRING(766) BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_rewrite' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_REWRITE_VCHAR
  INTEGER,
  BIGINT,
  VARCHAR(32765) BY DESCRIPTOR
  RETURNS INTEGER BY VALUE
  ENTRY_POINT 'raw_rewrite' MODULE_NAME 'librawudf';

DECLARE EXTERNAL FUNCTION RAW_GET
  INTEGER,
  INTEGER,
  BLOB RETURNS PARAMETER 3
  ENTRY_POINT 'raw_get' MODULE_NAME 'librawudf';
COMMIT WORK;