#include "yoyo.hc"

#ifdef __windoze
# include <winsock2.h>
#endif

#include <mysql.h>
#include <mysqld_error.h>

#ifdef _LIBYOYO
#define _YO_MYSQL_BUILTIN
#endif

#include <crtdbg.h>

#define _LIBYOYO


#include "../xddbfs.hc"
#include "../xddbmsql.hc"
#include "../prog.hc"
#include "../tesuite.hc"
#include "../xdatasec.hc"

YO_XDDB *Open_Xddb(int create_new)
  {
    char *db_source = Prog_Arguments_Count()?Prog_Argument(0):"xddb"; 
    YO_XDDB *xddb = 0;
    
    if ( 0 ) ;
    else if ( Str_Starts_With(db_source,"mysql://") )
      {
        xddb = XddbMsql_Connect(db_source,"",XDDB_FORMAT_ZIPPED_TEXT,create_new);
      }
    else
      {
        xddb = Xddbfs_Open(db_source,create_new,XDDB_FORMAT_TEXT,0);
      }
      
    return xddb;

        Tesuite_Info(__Format("xddb test, source: %s, format: %s",
                                    Xddb_Source_String(xddb),
                                    Xddb_Format_String(xddb)));
                                    
        unique = Xddb_Build_Unique_Key();
        doc = Xdata_Init();
        Xnode_Value_Set_Str(&doc->root,"unique",unique);
        Xnode_Value_Set_Str(&doc->root,"u","_%\032\b\t\r\n\\\'\"");
        Xdata_Sha1_Update(doc);
        key = Xddb_Unique(xddb,doc);
        doc = Xddb_Get(xddb,key,XDDB_RAISE_IF_DSNT_EXSIST);
        if ( !Xdata_Sha1_Verify(doc) )
          __Raise(YO_ERROR_TESUITE_FAIL,"document is not consistent");
        if ( strcmp(Xnode_Value_Get_Str(&doc->root,"unique",""),unique) )
          __Raise(YO_ERROR_TESUITE_FAIL,"document is not consistent");
        Xddb_Delete(xddb,key);
        if ( Xddb_Has(xddb,key) )
          __Raise(YO_ERROR_TESUITE_FAIL,"document still present in store");
        
        Tesuite_Case_Successed();

    else if ( xddb->doc_format == XDDB_FORMAT_BINARY )
      ;//Xdata_Binary_Encode_Into(bf,doc,0);
    else if ( xddb->doc_format == XDDB_FORMAT_ZIPPED_BINARY )
      ;//Xdata_Binary_Encode_Into(bf,doc,1);
    else
      __Raise(YO_ERROR_INCONSISTENT,__yoTa("unsupported document format",0));

    Unsigned_To_Hex2(Crc_8(0,bf->at+16,bf->count-16),bf->at+13);

    if ( xddb->esc_put || xddb->encrypt )
      {
        if ( xddb->encrypt )
          {
          }
        if ( xddb->esc_put ) __Auto_Release
          {

                bf = Buffer_Reserve(0,count);
                //Buffer_Unesc_Append(bf,at,count);
                at = bf->bytes;
                count = bf->count;
              }
          }
        
        if ( Crc_8(0,at+16,count-16) != Hex2_To_Unsigned(at+13) )
          __Raise(YO_ERROR_CORRUPTED,__yoTa("document corrupted",0));

        switch ( at[8] )
          {
            case XDDB_FORMAT_TEXT:
              doc = Def_Parse_Str(at+16);
              break;
            case XDDB_FORMAT_ZIPPED_TEXT:
              {

      {
        do 
          { 
            if ( *p == '\\' || *p == '"' 
              || *p == '\'' || *p == 0 
              || *p == '\b' || *p == '\n'
              || *p == '\r' || *p == '\t'
              //|| *p == '%' 
              //|| *p == '_' 
              || *p == 26  ) 
              break; 
            ++p; 
          } 
        while ( p != E );
        
        if ( q != p )
          Buffer_Append(bf,q,p-q);

                  __Vector_Append(&out,&len,&capacity,st->text,1);
                else if ( *st->text == 'n' )
                  __Vector_Append(&out,&len,&capacity,"\n",1);
                else if ( *st->text == 'r' )
                  __Vector_Append(&out,&len,&capacity,"\r",1);
                else if ( *st->text == 't' )
                  __Vector_Append(&out,&len,&capacity,"\t",1);
                else if ( *st->text == 'x' )
                  {
                    byte_t q = Str_Unhex_Byte(st->text+1,0,0);
                    st->text += 2;
                    __Vector_Append(&out,&len,&capacity,&q,1);
                  }
                else 
                  __Raise(YO_ERROR_ILLFORMED,__Format("invalid esc sequence at line %d",st->lineno));
              }
            else
              __Vector_Append(&out,&len,&capacity,st->text,1);
          }
          

# define STRICT_REQUIRE(Expr) REQUIRE(Expr)
# define STRICT_CHECK(Expr) (Expr)
#else
# define STRICT_REQUIRE(Expr) ((void)0)
# define STRICT_CHECK(Expr) (1)
#endif /* _STRICT */

enum 
  { 
    YO_OBJECT_SIGNATURE_PFX  =  0x00594f59, /*'YOY'*/  
    YO_OBJECT_SIGNATURE_HEAP =  0x4f594f59, /*'YOYO'*/  
    YO_MEMPOOL_PIECE_MAXSIZE = 1*KILOBYTE,
    YO_MEMPOOL_PIECE_ON_BLOCK= 16,
    YO_MEMPOOL_PIECE_STEP    = 64,
    YO_MEMPOOL_SLOTS_COUNT   = YO_MEMPOOL_PIECE_MAXSIZE/YO_MEMPOOL_PIECE_STEP,
  };

__Static_Assert(YO_MEMPOOL_SLOTS_COUNT <= 'O');

#ifdef _YO_CORE_BUILTIN
void **Yo_Mempool_Blocks = 0;
void *Yo_Mempool_Slots[YO_MEMPOOL_SLOTS_COUNT] = {0,};
int Yo_Mempool_Counts[YO_MEMPOOL_SLOTS_COUNT] = {0,};
#endif

#define Slist_Remove_By(ListPtr,Next,Val) Yo_Slist_Remove((void**)ListPtr,(int)((size_t)(&(*ListPtr)->Next)-(size_t)(*ListPtr)),Val)
#define Slist_Remove(ListPtr,Val) Slist_Remove_By(ListPtr,next,Val)

void Yo_Slist_Remove(void **p, int offs_of_next, void *val)
#ifdef _YO_CORE_BUILTIN
  {
    if ( p ) 

  }
#endif
  ;

void Yo_Global_Cleanup()
#ifdef _YO_CORE_BUILTIN
  {
    while ( Yo_Mempool_Blocks )
      {
        void **Q = Yo_Mempool_Blocks;
        Yo_Mempool_Blocks = *Q;
        free(Q[1]);
        free(Q);
      }
  }
#endif
  ;

void *Yo_Malloc(unsigned size)
  _YO_CORE_BUILTIN_CODE({return Yo_Pool(Yo_Malloc_Npl(size));});
void *Yo_Realloc(void *p,unsigned size)

    f->func = func;

    return o;
  }
#endif
  ;


















void Yo_Mempool_Free(void *p,int plidx)
#ifdef _YO_CORE_BUILTIN
  {
    void **Q = p;
    STRICT_REQUIRE(plidx >= 0 && plidx <YO_MEMPOOL_SLOTS_COUNT); 
    for (;;)
      {

    __Xchg_Interlock
      {
        void * volatile *S = Yo_Mempool_Slots+plidx;
        if ( !*S )
          {
            int i,piece = (plidx+1)*YO_MEMPOOL_PIECE_STEP; 
            void **Q = Yo_Malloc_Npl(piece*YO_MEMPOOL_PIECE_ON_BLOCK);
            void **R = Yo_Malloc_Npl(sizeof(void*)*2);
            R[1] = Q;
            R[0] = Yo_Mempool_Blocks;
            Yo_Mempool_Blocks = R;
            Yo_Mempool_Counts[plidx] += YO_MEMPOOL_PIECE_ON_BLOCK;
            for ( i=0; i < YO_MEMPOOL_PIECE_ON_BLOCK; ++i, Q = (void**)((byte_t*)Q + piece) )
              for (;;)
                {
                  *Q = *S;
                  if ( __Atomic_CmpXchg_Ptr(S,Q,*Q) ) break;
                }

        case ZLIB_VERSION_ERROR: return "Z_VERSION_ERROR";
      }
    return "unknown error";
  }
#endif
  ;
  
#undef compress
int compress(void *dst, long *dst_len, void *src, long src_len);
#undef uncompress
int uncompress(void *dst, long *dst_len, void *src, long src_len);

int Zlib_Compress(void *dst, long *dst_len, void *src, long src_len)
#ifdef _YO_ZLIB_BUILTIN
  {
    return compress(dst,dst_len,src,src_len);
  }
#endif