#include <stdio.h>
#include <stdlib.h>
#include "btree.h"

bool 
operator ==(uPtr u1, uPtr u2) {
  return (u1.offset == u2.offset);
} // overloaded operator ==

bTree::bTree(char * filename, uInt32 nodeSize, treeTypes tt, bTreeVFS * virtualFS) {
  filename = filename;
  nodeSize = nodeSize;
  tt = tt;
  vfs = virtualFS;
  return;
} // bTree::bTree

int
bTree::align(int keyLength) {
  return ((sizeof(uPtr) + keyLength + 7) >> 3) << 3;
} // bTree::align

int
bTree::calcSize(TbNode * node) {
  int size;
  TbNodeData * dataNode;

  if (node == NULL) return 0;
  dataNode = &node->data;
  size = (int)dataNode - (int)node;
  
  for (unsigned int curNode = 1; curNode <= node->numKeys; curNode++) {
    size += align(keySize(&dataNode->key));
//mjikaboom    dataNode += align(keySize(&dataNode->key)));
  } // for curNode 
  return size;
} // bTree::calcSize

void
bTree::discardPage(TbNode *) {

} // bTree::discardPage

bool
bTree::isNull(uPtr u) {
  return (u.offset == 0);
} // bTree::isNull

uPtr
bTree::getFirstDeleted(void) {

  if (!memoryTree) {
    if (!vfs->fSeek((int)&info->firstDeleted - (int)info)) exit(42);
    if (!vfs->fRead(&info->firstDeleted, sizeof(info->firstDeleted))) exit(42);
  } // if not memoryTree

  return info->firstDeleted;
} // bTree::getFirstDeleted

uInt32
bTree::getNodes(void) {

  if (!memoryTree) {
    if (!vfs->fSeek((int)&info->nodes - (int)info)) exit(42);
    if (!vfs->fRead(&info->nodes, sizeof(info->nodes))) exit(42);
  } // if not memoryTree

  return info->nodes;
} // bTree::getNodes

uInt32 
bTree::getHeight(void) {

  if (!memoryTree) {
    if (!vfs->fSeek((int)&info->height - (int)info)) exit(42);
    if (!vfs->fRead(&info->height, sizeof(info->height))) exit(42);
  } // if not memoryTree
 
  return info->height;
} // bTree::getHeight

uInt32
bTree::getKeys(void) {
  
  if (!memoryTree) {
    if (!vfs->fSeek((int)&info->keys - (int)info)) exit(42);
    if (!vfs->fRead(&info->keys, sizeof(info->keys))) exit(42);
  } // if not memoryTree

  return info->keys;
} // bTree::getKeys

uPtr
bTree::getRoot(void) {
  
  if (info == NULL) {
    uPtr result;
    setNull(result);
    return result;
  } // if info == NULL

  if (!memoryTree) {
    if (!vfs->fSeek((int)&info->root - (int)info)) exit(42);
    if (!vfs->fRead(&info->root, sizeof(info->root))) exit(42);
  } // if not memoryTree

  return info->root;
} // bTree::getRoot

TbNode *
bTree::loadPage(uPtr u) {
  TbNode * node;

  if (isNull(u)) return NULL;

  if (memoryTree) 
    node = u.bPtr;
  else {
    if (!vfs->fSeek((int)u.offset * info->bNodeSize)) exit(42);
    node = (TbNode *)malloc(info->bNodeSize);
    if (node == NULL) return NULL;
    if (!vfs->fRead(node, info->bNodeSize)) exit(42);
  } // else

  return node;
} // bTree::loadPage

void
bTree::savePage(TbNode *) {

} // bTree::savePage

void
bTree::setFirstDeleted(uPtr value) {
  info->firstDeleted = value;
  if (!memoryTree) {
    if (!vfs->fSeek((int)&info->firstDeleted - (int)info)) exit(42);
    if (!vfs->fWrite(&info->firstDeleted, sizeof(info->firstDeleted))) exit(42);
  } // if not memoryTree

} // bTree::setFirstDeleted

void
bTree::setNodes(uInt32 value) {
  info->nodes = value;

  if (!memoryTree) {
    if (!vfs->fSeek((int)&info->nodes - (int)info)) exit(42);
    if (!vfs->fWrite(&info->nodes, sizeof(info->nodes))) exit(42);
  } // if not memoryTree

} // bTree::setNodes

void
bTree::setHeight(uInt32 value) {
  info->height = value;

  if (!memoryTree) {
    if (!vfs->fSeek((int)&info->height - (int)info)) exit(42);
    if (!vfs->fWrite(&info->height, sizeof(info->height))) exit(42);
  } // if not memoryTree

} // bTree::setHeight

void
bTree::setKeys(uInt32 value) {
  info->keys = value;

  if (!memoryTree) {
    if (!vfs->fSeek((int)&info->keys - (int)info)) exit(42);
    if (!vfs->fWrite(&info->keys, sizeof(info->keys))) exit(42);
  } // if not memoryTree

} // bTree::getKeys

void 
bTree::setLeft(uPtr u, uPtr newPtr) {
  TbNode * node = loadPage(u);
  if (node == NULL) return;

  node->left = newPtr;
  savePage(node);
  discardPage(node);
} // bTree::setLeft

void
bTree::setParent(uPtr u, uPtr newPtr) {
  TbNode * node = loadPage(u);
  if (node == NULL) return;

  node->parent = newPtr;
  savePage(node);
  discardPage(node);
} // bTree::setParent

void
bTree::setRight(uPtr u, uPtr newPtr) {
  TbNode * node = loadPage(u);
  if (node == NULL) return;

  node->right = newPtr;
  savePage(node);
  discardPage(node);
} // bTree::setRight

void
bTree::setRoot(uPtr value) {
  info->root = value;

  if (!memoryTree) {
    if (!vfs->fSeek((int)&info->root - (int)info)) exit(42);
    if (!vfs->fWrite(&info->root, sizeof(info->root))) exit(42);
  } // if not memoryTree
  return;
} // bTree::setRoot

void
bTree::setNull(uPtr & u) {
  u.offset = 0;
} // bTree::setNull

void
bTree::InstallUserFunctions(compareKeyFunc cmpFunc, copyKeyProc copyProc, keySizeFunc ksFunc) {
  compareKey = cmpFunc;
  copyKey = copyProc;
  keySize = ksFunc;
  return;
} // bTree::InstallUserFunctions

bTree::~bTree(void) {
  return;
} // bTree::~bTree