#include <stddef.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <iostream>

#include "ubixfs.h"
#include "btree.h"

using namespace std;

UbixFS::UbixFS(void) { 
  device = NULL;
  freeBlockList = NULL;
  superBlock = NULL;
  root = NULL;
} // UbixFS::UbixFS


UbixFS::UbixFS(device_t * dev) {
  device = dev;
  freeBlockList = NULL;
  superBlock = NULL;
  root = NULL;
} // UbixFS::UbixFS

void
UbixFS::printSuperBlock(void) {
  printf("superBlock->name........... %s\n", superBlock->name);
  printf("superBlock->magic1......... %X\n", superBlock->magic1);
  printf("superBlock->fsByteOrder.... %d\n", superBlock->fsByteOrder);
  printf("superBlock->blockSize...... %d\n", superBlock->blockSize);
  printf("superBlock->blockShift..... %d\n", superBlock->blockShift);
  printf("superBlock->numBlocks...... %lld\n", superBlock->numBlocks);
  printf("superBlock->usedBlocks..... %lld\n", superBlock->usedBlocks);
  printf("superBlock->batSectors..... %d\n", superBlock->batSectors);
  printf("superBlock->inodeCount..... %d\n", superBlock->inodeCount);
  printf("superBlock->magic2......... %X\n", superBlock->magic2);
  printf("superBlock->blocksPerAG.... %d\n", superBlock->blocksPerAG);
  printf("superBlock->AGShift........ %d\n", superBlock->AGShift);
  printf("superBlock->numAGs......... %d\n", superBlock->numAGs);
  printf("superBlock->lastUsedAG..... %d\n", superBlock->lastUsedAG);
  printf("superBlock->flags.......... %X\n", superBlock->flags);
  printf("superBlock->magic3......... %X\n", superBlock->magic3);
  return;
} // UbixFS::printSuperBlock

int 
UbixFS::vfs_init(void) {
assert(device);
  size_t result;
  cout << "vfs_init()" << endl;
  assert(device);

  if (device == NULL) return -1;
  if (superBlock != NULL) delete superBlock;
  superBlock = new diskSuperBlock;
assert(superBlock);
  if (superBlock == NULL) return -1;

  // read in the superBlock. It's always the last block on the partition 
cout << "reading in superBlock" << endl;
  device->read(device, superBlock, device->sectors-1, 1);
cout << "done" << endl;

  assert(superBlock->magic1 == UBIXFS_MAGIC1);
  assert(superBlock->magic2 == UBIXFS_MAGIC2);
  assert(superBlock->magic3 == UBIXFS_MAGIC3);
  assert(strcmp(superBlock->name, "UbixFS") == 0);
  assert((1 << superBlock->blockShift) == superBlock->blockSize);
  assert((unsigned)(1 << superBlock->AGShift) == superBlock->blocksPerAG);
  assert(superBlock->flags == UBIXFS_CLEAN);

  if (freeBlockList != NULL) delete [] freeBlockList;
  freeBlockList = new signed char[superBlock->batSectors*512];
assert(freeBlockList);
  memset(freeBlockList, 0, superBlock->batSectors*512);

  device->read(device, 
               freeBlockList, 
               device->sectors - superBlock->batSectors-1,
               superBlock->batSectors
              ); // device->read()

  root = new fileDescriptor;
  assert(root);
  memset(root, 0, sizeof(fileDescriptor));
cout << "allocating root dir inode" << endl;
  root->inode = new ubixfsInode;
  memset(root->inode, 0, sizeof(ubixfsInode));
cout << "root dir inode starting sector: " << 
               ((superBlock->rootDir.AG << superBlock->AGShift) 
               + superBlock->rootDir.start) * (superBlock->blockSize / 512)
     << endl;

cout << "reading in root dir inode" << endl;
  
  device->read(device,
               root->inode,
               ((superBlock->rootDir.AG << superBlock->AGShift) 
                 + superBlock->rootDir.start) * (superBlock->blockSize / 512),
               sizeof(ubixfsInode) / 512
              );
cout << "done" << endl;
  ubixfsInode * rootInode = static_cast<ubixfsInode *>(root->inode);
  assert(rootInode);
  rootInode->data.btPtr = new bTree();
cout << "reading in root dir header" << endl;
  result = vfs_read(root, rootInode->data.btPtr->header, 0, sizeof(bTreeHeader));
  assert(result == sizeof(bTreeHeader));

/*
  device->read(device,
               rootInode->data.btPtr->header,
               ((rootInode->blocks.direct[0].AG << superBlock->AGShift)
                 + rootInode->blocks.direct[0].start) 
                 * (superBlock->blockSize / 512),
               sizeof(bTreeHeader) / 512
              );
 */
cout << "done" << endl;
  rootInode->data.btPtr->Info();
  printSuperBlock();
  return 0;
} // UbixFS::init

size_t
UbixFS::vfs_read(fileDescriptor * fd, void * data, off_t offset, size_t size) {
  
  unsigned int i;
  off_t sum, startingBlock;
  size_t runSize, sectorCount, totalSize, bSize; // blockSize
  ubixfsInode * inode = NULL;

  if (fd == NULL || data == NULL) return ~0;

  if (size == 0) return 0; // don't fail if size is 0?
   
  assert(device);
  assert(superBlock);

  inode = static_cast<ubixfsInode *>(fd->inode);

  assert(inode);

  bSize = superBlock->blockSize;

  totalSize = sum = i = 0;
  
  while (size > 0) {

    /*
     * place check here to see which set of blocks we're looking through
     */

    // scan through direct blocks
    do {
      if (offset >= sum && offset < sum + inode->blocks.direct[i].len * bSize)          break;

      sum += inode->blocks.direct[i++].len * bSize;
     
    } while (i < NUM_DIRECT_BLOCKS);

cout << "i == " << i << endl;
    startingBlock = (inode->blocks.direct[i].AG << superBlock->AGShift) + 
                     inode->blocks.direct[i].start + ((offset - sum) / bSize);

cout << "inode->blocks.direct[" << i << "]." << inode->blocks.direct[i].len;
cout << endl;
    runSize = inode->blocks.direct[i].len * bSize;

cout << "runSize: " << runSize << endl;
    // startingBlock is in 4k blocks
    startingBlock *= (bSize / 512);
    // startingBlock is now in sectors


    if (runSize >= size) {
      runSize = size;
      size = 0;
    } else { 
      size -= runSize;
    } // else

    sectorCount = runSize / 512;
  
    cout << "device->read(device, data, " << startingBlock << ", ";
    cout << sectorCount << ");" << endl; 

    device->read(device, data, startingBlock, sectorCount);

    (uInt8 *)data += runSize;
    totalSize += runSize;
  } // while  
  return totalSize;
} // UbixFS::vfs_read

blockRun
UbixFS::getFreeBlock(blockRun ibr) {
  signed char * ptr;
  signed char * holdPtr;
  int32 count, holdCount;

  blockRun obr = {0, 0, 0};  // output block run

  // Check to make sure none of these are null
  if (device == NULL || freeBlockList == NULL || superBlock == NULL) return obr;

  if (ibr.len == 0) return obr;

  if (ibr.len > superBlock->numBlocks) return obr;

  if (ibr.len == 1) return getFreeBlock(ibr.AG);
  /*
   * count is the block from the base of the list.
   * Since we're given a specific AG to look through, we start the count at
   * AG << AGShift, where AGShift is the shift value of the number of blocks
   * in an AG
   */

  count = (ibr.AG << superBlock->AGShift);

  /*
   * The freeBlockList is a bit map of the free/used blocks.
   * Used = on bit
   * Unused = off bit
   * There are 8 bits per byte (hopefully) and so we have to divide the count
   * by 8 to get our starting byte offset to look from
   */

  ptr = freeBlockList + (count >> 3);

rescan:
  // look for the first free 8 blocks (this may create holes)
  while (*ptr != 0) {
    ++ptr;
    count += 8;
    if (count+8 > superBlock->numBlocks) {
      ptr = freeBlockList;
      count = 0;
    } // if 
  } // while *ptr != 0

  holdPtr = ptr;
  holdCount = count;

  for (unsigned short i = 0; i < ((ibr.len+7) / 8); i++) {
    ++ptr;
    count += 8;
    if (count+8 > superBlock->numBlocks) {
      ptr = freeBlockList;
      count = 0;
      goto rescan;
    } // if
    if (*ptr != 0) goto rescan;
  } // for i

  // we have found a range of blocks that work for us

  obr.AG = holdCount / superBlock->blocksPerAG;
  obr.start = holdCount % superBlock->blocksPerAG;
  obr.len = ibr.len;

  for (unsigned short i = 0; i < (ibr.len / 8); i++) {
    *holdPtr = -1;
    ++holdPtr;
  } // for

  if (ibr.len % 8 != 0) *holdPtr = (-1 << (8-(ibr.len % 8)));

  superBlock->usedBlocks += ibr.len;   // increment the number of used blocks
  return obr;
} // UbixFS::getFreeBlock

blockRun
UbixFS::getFreeBlock(uInt32 AG) {
  // AG == AllocationGroup
  blockRun br;
  signed char * ptr;
  int32 count;
  int32 subCount = 128;

  br.AG = 0;
  br.start = 0;
  br.len = 0;
  // Check to make sure neither of these are null
  if (device == NULL || freeBlockList == NULL || superBlock == NULL) return br;

  // Are there any blocks available?
  if (superBlock->numBlocks == superBlock->usedBlocks) return br;

  /* 
   * count is the block from the base of the list.
   * Since we're given a specific AG to look through, we start the count at
   * AG << AGShift, where AGShift is the shift value of the number of blocks
   * in an AG 
   */

  count = (AG << superBlock->AGShift);

  /*
   * The freeBlockList is a bit map of the free/used blocks. 
   * Used = on bit
   * Unused = off bit
   * There are 8 bits per byte (hopefully) and so we have to divide the count
   * by 8 to get our starting byte offset to look from
   */

  ptr = freeBlockList + (count >> 3);

  // Scan through the freeBlockList 

rescan:
  while (*ptr == -1) { 
    ++ptr;
    count += 8;
    if (count+8 > superBlock->numBlocks) break;
  } // while *ptr == -1

  subCount = 128;

  do {
    if ((*ptr & subCount) == 0) break;
    subCount >>= 1;
    ++count;
    if (count == superBlock->numBlocks) {
      count = 0;
      ptr = freeBlockList;
      goto rescan;
    } // if
  } while(subCount > 1);

  *ptr |= subCount;           // mark this block as used
  ++superBlock->usedBlocks;   // increment the number of used blocks

  br.AG = count / superBlock->blocksPerAG; 
  br.start = count % superBlock->blocksPerAG;
  br.len = 1;
  return br;               // return the allocated block number
} // Ubixfs::getFreeBlock

uInt32
UbixFS::getNextAG(void) {

  if (superBlock->lastUsedAG == superBlock->numAGs) 
    superBlock->lastUsedAG = 0;
  else
    superBlock->lastUsedAG++;
  return superBlock->lastUsedAG;

} // UbixFS::getNextAG

/*
 * UbixFS::getFreeBlock(void)
 * upon success returns a free block based on the next AG after the lastUsedAG
 * failure returns -1
 */

blockRun
UbixFS::getFreeBlock(void) {
  return getFreeBlock(getNextAG());
} // UbixFS::getFreeBlock

blockRun
UbixFS::get8FreeBlocks(uInt32 AG) {
  // AG == AllocationGroup
  blockRun br;
  signed char * ptr;
  signed char * endPtr;
  int32 count;

  br.AG = 0;
  br.start = 0;
  br.len = 0;

  if (device == NULL || freeBlockList == NULL || superBlock == NULL) return br;

  // Are there any blocks available?
  if (superBlock->usedBlocks+8 > superBlock->numBlocks) return br;

  /*
   * count is the block from the base of the list.
   * Since we're given a specific AG to look through, we start the count at
   * AG << AGShift, where AGShift is the shift value of the number of blocks
   * in an AG
   */

  count = (AG << superBlock->AGShift);

  ptr = freeBlockList + (count >> 3);
  
  endPtr = freeBlockList + (superBlock->numBlocks >> 3);

  bool secondTime = false;
  while (*ptr != 0) {
    ++ptr;
    count += 8;
    if (ptr == endPtr) {
      if (secondTime) 
        return br; 
      else 
        secondTime = true;

      count = 0;
      ptr = freeBlockList;      
    } // if
  } // while 

  *ptr = -1;   // mark 8 blocks as taken

  br.AG = count / superBlock->blocksPerAG;
  br.start = count % superBlock->blocksPerAG;
  br.len = 8;
  return br;
} // UbixFS::get8FreeBlocks

void *
UbixFS::mknod(const char *filename, ubixfsInode * parent) {
  ubixfsInode * inode = NULL;

  inode = new ubixfsInode;
  assert(inode);
  if (inode == NULL) return NULL;
  memset(inode, 0, sizeof(ubixfsInode));

  inode->magic1 = UBIXFS_INODE_MAGIC;

  /* 
   * in retrospect.. I'm not sure why parent would be null.. only the
   * root directory would have a null parent, but that's manually allocated
   * in vfs_format()
   */

  if (parent == NULL) {
    inode->inodeNum = getFreeBlock();
    inode->parent.iAddr.AG = 0;
    inode->parent.iAddr.start = 0;
    inode->parent.iAddr.len = 0;
  } else {
    inode->inodeNum = getFreeBlock(parent->inodeNum.AG);
    inode->parent.iAddr = parent->inodeNum;
  } // else
   
  strncpy(inode->name, filename, MAX_FILENAME_LENGTH);

  inode->uid = getuid();
  inode->gid = getgid();
  // inode->mode
  // inode->flags
  // inode->createTime
  // inode->lastModifiedTime
  // inode->type 
  inode->inodeSize = superBlock->inodeSize;

  /*
   * next and prev are used in memory to hold pointers to the next/prev
   * inodes in this dir.  On disk they may have another value, but for
   * now they should be set to null.
   */

  inode->next.offset = 0;
  inode->prev.offset = 0;
  ++superBlock->inodeCount;
  return inode;
} // UbixFS::mknod

void *
UbixFS::vfs_mknod(const char *path, mode_t mode) {
  return mknod(path, 0);
} // UbixFS::mknod

void 
UbixFS::printFreeBlockList(uInt32 AG) {
  unsigned int j;
  if (superBlock == NULL || freeBlockList == NULL) return;
  printf("AG = %d\n", AG);
  for (unsigned int i = 0; i < superBlock->blocksPerAG / 8; i++) {
    j = 128;
    signed char foo = freeBlockList[(AG << superBlock->AGShift)+i];
    while (j > 0) {
      if ((foo & j) == j) 
        printf("1");
      else
        printf("0");    
      j >>= 1;
 
    }
  } // for i
  printf("\n");
  return;
} // UbixFS::printFreeBlockList

int
UbixFS::vfs_format(device_t * dev) {
  cout << "vfs_format()" << endl;
  char sector[512];
  uInt32 blocks, batSect, batSize;
  if (dev == NULL) return -1; 

  // zero out the sector
  memset(&sector, 0x0, sizeof(sector));
 
  // fill the drive in with zeroed out sectors
  cout << "dev->sectors: " << dev->sectors << endl;
  cout << "clearing device...";

  for (unsigned int i = 0; i < dev->sectors; i++) {
    dev->write(dev, &sector, i, 1);
  } // for i

  cout << "done" << endl;

  // allocate a new superBlock and clear it

  diskSuperBlock *sb = new diskSuperBlock;
  if (sb == NULL) return -1;
  memset(sb, 0, sizeof(diskSuperBlock));

  // dev->sectors is the number of 512 byte sectors

  blocks = (dev->sectors-1) / 8;     // 4k blocks
  batSize = (dev->sectors-1) % 8;    // remainder
  
  // compute the BAT size

  while ((batSize * 4096) < blocks) {
    batSize += 8;
    --blocks;
  } // while
 
  // batSize is in sectors
  batSect = blocks * 8;

  strcpy(sb->name, "UbixFS");
  sb->magic1 = UBIXFS_MAGIC1;
  sb->fsByteOrder = 0;
  sb->blockSize = 4096;
  sb->blockShift = 12;
  sb->numBlocks = blocks;
  sb->usedBlocks = 2;  // root dir takes two blocks (inode + bTree header)
  sb->inodeCount = 1;
  sb->inodeSize = 4096;
  sb->magic2 = UBIXFS_MAGIC2;
  sb->blocksPerAG = 2048;
  sb->AGShift = 11;
  sb->numAGs = (sb->numBlocks+2047) / 2048;
  sb->lastUsedAG = 0;

  // the BAT exists outside our official block count, so no 
  // entries in the BAT need to be set for it
  sb->batSectors = batSize;

  sb->flags = 0x434C454E; // CLEN
  sb->logBlocks.AG = 0;
  sb->logBlocks.start = 0;
  sb->logBlocks.len = 0;
  sb->logStart = 0;
  sb->logEnd = 0;
  sb->magic3 = UBIXFS_MAGIC3;
  sb->indicies.AG = 0;
  sb->indicies.start = 0;
  sb->indicies.len = 0;

  sb->rootDir.AG = 0;
  sb->rootDir.start = 0;
  sb->rootDir.len = 1;

  // write out the superBlock

  dev->write(dev, sb, dev->sectors-1, 1);

  // mark the first two 4k blocks used
  memset(&sector, 0, sizeof(sector));
  sector[0] = (1 << 7) | (1 << 6);

  // write out the first sector of the BAT 

  dev->write(dev, &sector, batSect, 1);
  // clear the rest
  sector[0] = 0;

  // write out the rest of the BAT

  for (unsigned int i = 1; i < batSize; i++) {
    dev->write(dev, &sector, (batSect)+i, 1);
  } // for i

  /* allocate part of the root dir */

  // sanity checks
  assert(sb->blockSize);
  assert((unsigned)sb->blockSize >= sizeof(bTreeHeader));

  bTreeHeader * bth = new bTreeHeader;
  assert(bth);
  memset(bth, 0, sizeof(bTreeHeader));

  bth->firstDeleted = -1;
  bth->firstNodeOffset = -1;
  bth->treeDepth = 1;
  bth->treeWidth = 0;
  bth->treeLeafCount = 0;

  /* create the root dir inode here */

  ubixfsInode * inode = new ubixfsInode;
  assert(inode);
  if (inode == NULL) return -1;
  memset(inode, 0, sizeof(ubixfsInode));

  inode->magic1 = UBIXFS_INODE_MAGIC;

  // inodes point to themselves
  inode->inodeNum.AG = 0;
  inode->inodeNum.start = 0;
  inode->inodeNum.len = 1;

  // root dir has no parent directory
  inode->parent.iAddr.AG = 0;
  inode->parent.iAddr.start = 0;
  inode->parent.iAddr.len = 0;

  /* this is part of the root dir structure (the bTreeHeader) */
  inode->blocks.direct[0].AG = 0;
  inode->blocks.direct[0].start = 1;
  inode->blocks.direct[0].len = 1;
   
  inode->blocks.maxDirectRange = sizeof(bTreeHeader);
  inode->blocks.size = sizeof(bTreeHeader);

  strcpy(inode->name, "/");
  inode->uid = getuid();
  inode->gid = getgid();
  // inode->mode
  inode->flags = INODE_DIRECTORY;
  // inode->createTime
  // inode->lastModifiedTime
  // inode->type
  inode->inodeSize = sb->inodeSize;

  /*
   * next and prev are used in memory to hold pointers to the next/prev
   * inodes in this dir.  On disk they may have another value, but for
   * now they should be set to null.
   */

  inode->next.offset = 0;
  inode->prev.offset = 0;

  // write out the "root" dir inode

  dev->write(dev, 
             inode, 
             ((inode->inodeNum.AG << sb->AGShift) +
              inode->inodeNum.start) * (sb->blockSize / 512),
             sb->inodeSize / 512
            ); // dev->write

  // write out the "root" dir

  dev->write(dev, 
             bth, 
             ((inode->blocks.direct[0].AG << sb->AGShift) + 
              inode->blocks.direct[0].start) * (sb->blockSize / 512),
             sb->blockSize / 512
            ); // dev->write

  delete inode;
  delete bth;
  delete sb;
  cout << "format complete" << endl;
  return 0;
} // UbixFS::vfs_format

int
UbixFS::vfs_stop(void) {
  if (vfs_sync() != 0) return -1;

  // you must delete the root dir first, in case it needs to
  // still write anything out

  if (root != NULL) {
    ubixfsInode * rootInode = static_cast<ubixfsInode *>(root->inode);
    delete rootInode->data.btPtr; 
    delete rootInode;
    root->inode = NULL;
    
  } // if

  delete root;
  delete [] freeBlockList;
  delete superBlock;

  freeBlockList = NULL;
  superBlock = NULL; 
  root = NULL;

  /* 
   * The device isn't null at this point, allowing for people to restart
   * the mount point. Or, alternatively, to blow things up.
   */
  
  return 0;
} // UbixFS::vfs_stop

int
UbixFS::vfs_sync(void) {
  if (device == NULL || superBlock == NULL || freeBlockList == NULL) return -1;
  device->write(device, 
                freeBlockList, 
                device->sectors - superBlock->batSectors - 1, 
                superBlock->batSectors
               );
  device->write(device, superBlock, device->sectors-1, 1);
  return 0;
} // UbixFS::vfs_sync

UbixFS::~UbixFS(void) {
  delete [] freeBlockList;
  return;
}