#ifndef _HFPAGE_H
#define _HFPAGE_H

#include "minirel.h"
#include "page.h"


const int INVALID_SLOT =  -1;
const int EMPTY_SLOT   =  -1;

// Class definition for a minibase data page.   
// The design assumes that records are kept compacted when
// deletions are performed. Notice, however, that the slot
// array cannot be compacted.  Notice, this class does not keep
// the records aligned, relying instead on upper levels to take
// care of non-aligned attributes.

class HFPage {

  protected:
    struct slot_t {
        short   offset;  
        short   length;    // equals EMPTY_SLOT if slot is not in use
    };

    static const int DPFIXED =       sizeof(slot_t)
                           + 4 * sizeof(short)
                           + 3 * sizeof(PageId);

      // Warning:
      // These items must all pack tight, (no padding) for
      // the current implementation to work properly.
      // Be careful when modifying this class.

    short     slotCnt;     // number of slots in use
    short     usedPtr;     // offset of first used byte in data[]
    short     freeSpace;   // number of bytes free in data[]

    short     type;        // an arbitrary value used by subclasses as needed

    PageId    prevPage;    // backward pointer to data page
    PageId    nextPage;    // forward pointer to data page
    PageId    curPage;     // page number of this page

    slot_t    slot[1];     // first element of slot array.

    char      data[MAX_SPACE - DPFIXED]; 

  public:
    void init(PageId pageNo);   // initialize a new page
    void dumpPage();            // dump contents of a page

    PageId getNextPage();       // returns value of nextPage
    PageId getPrevPage();       // returns value of prevPage

    void setNextPage(PageId pageNo);    // sets value of nextPage to pageNo
    void setPrevPage(PageId pageNo);    // sets value of prevPage to pageNo

    PageId page_no() { return curPage;} // returns the page number

    // inserts a new record pointed to by recPtr with length recLen onto
    // the page, returns RID of record 
    Status insertRecord(char *recPtr, int recLen, RID& rid);

    // delete the record with the specified rid
    Status deleteRecord(const RID& rid);

      // returns RID of first record on page
      // returns DONE if page contains no records.  Otherwise, returns OK
    Status firstRecord(RID& firstRid);

      // returns RID of next record on the page 
      // returns DONE if no more records exist on the page
    Status nextRecord (RID curRid, RID& nextRid);

      // copies out record with RID rid into recPtr
    Status getRecord(RID rid, char *recPtr, int& recLen);

      // returns a pointer to the record with RID rid
    Status returnRecord(RID rid, char*& recPtr, int& recLen);

      // returns the amount of available space on the page
    int    available_space(void);

      // Returns true if the HFPage is has no records in it, false otherwise.
    bool empty(void);

};

#endif // _HFPAGE_H

#ifndef _HEAPFILE_H
#define _HEAPFILE_H

#include "minirel.h"
#include "page.h"
#include "hfpage.h"
#include "scan.h"
#include "buf.h"
#include "db.h"
#include "new_error.h"

//  This heapfile implementation is directory-based. We maintain a
//  directory of info about the data pages (which are of type HFPage
//  when loaded into memory).  The directory itself is also composed
//  of HFPages, with each record being of type DataPageInfo
//  as defined below.
//
//  The first directory page is a header page for the entire database
//  (it is the one to which our filename is mapped by the DB).
//  All directory pages are in a doubly-linked list of pages, each
//  directory entry points to a single data page, which contains
//  the actual records.
//
//  The heapfile data pages are implemented as slotted pages, with
//  the slots at the front and the records in the back, both growing
//  into the free space in the middle of the page.
//  See the file 'hfpage.h' for specifics on the page implementation.
//
//  We can store roughly pagesize/sizeof(DataPageInfo) records per
//  directory page; for any given HeapFile insertion, it is likely
//  that at least one of those referenced data pages will have
//  enough free space to satisfy the request.

// Error codes for HEAPFILE.
enum heapErrCodes {
    BAD_RID,
    BAD_REC_PTR,
    HFILE_EOF,
    INVALID_UPDATE,
    NO_SPACE,
    NO_RECORDS,
    END_OF_PAGE,
    INVALID_SLOTNO,
    ALREADY_DELETED,
};

// DataPageInfo: the type of records stored on a directory page:

struct DataPageInfo {
  int    availspace;  // total available space of a page: HFPage returns int for avail space, so we use int here
  int    recct;       // number of records in the page: for efficient implementation of getRecCnt()
  PageId pageId;      // page id: id of this particular data page (a HFPage)
};

class HeapFile {

  public:

    // Initialize.  A null name produces a temporary heapfile which will be
    // deleted by the destructor.  
    // If the name already denotes a file, the
    // file is opened; otherwise, a new empty file is created.
    HeapFile( const char *name, Status& returnStatus ); 
    ~HeapFile();

    // return number of records in file
    int getRecCnt();
    
    // insert record into file
    Status insertRecord(char *recPtr, int recLen, RID& outRid); 
    
    // delete record from file
    Status deleteRecord(const RID& rid); 

    // updates the specified record in the heapfile.
    Status updateRecord(const RID& rid, char *recPtr, int reclen);

    // read record from file, returning pointer and length
    Status getRecord(const RID& rid, char *recPtr, int& recLen); 

    // initiate a sequential scan
    class Scan *openScan(Status& status);

    // delete the file from the database
    Status deleteFile();


  private:
    friend class Scan;

    PageId      firstDirPageId;  // page number of header page
    int         file_deleted;     // flag for whether file is deleted (initialized to be false in constructor)
    char       *fileName;     // heapfile name

    // get new data pages through buffer manager
    // (dpinfop stores the information of allocated new data pages)
    Status newDataPage(DataPageInfo *dpinfop);
    
    // return a data page (rpDataPageId, rpdatapage) containing a given record (rid) 
    // as well as a directory page (rpDirPageId, rpdirpage) containing the data page and RID of the data page (rpDataPageRid)
    Status findDataPage(const RID& rid, 
            PageId &rpDirPageId, HFPage *&rpdirpage, 
            PageId &rpDataPageId,HFPage *&rpdatapage, 
            RID &rpDataPageRid);

    // put data page information (dpinfop) into a dir page(s)
    Status allocateDirSpace(struct DataPageInfo * dpinfop,/* data page information*/
                            PageId &allocDirPageId,/*Directory page having the first data page record*/
                            RID &allocDataPageRid /*RID of the first data page record*/);
};


#endif    // _HEAPFILE_H