#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#define ERASED     0
#define VALID       1
#define INVALID     2

#define M_READ      0
#define M_WRITE     1

#define NUMOFPAGE   64          // total # of page == # of page table
#define NUMOFBLOCK  16          // total # of block
#define NUMOFPAGEINBLOCK    4   // # of page in block
#define STATE  0           // To store [valid, invalid, erased]
int pagetable[NUMOFPAGE];
int totwritecnt = 0;

// page struct
typedef struct NANDpage {
        unsigned char data[512];
        char spare[16];
} NANDpage;

// block struct
typedef struct NANDblock {
        NANDpage pageinB[NUMOFPAGEINBLOCK];
} NANDblock;

NANDblock *nb;

// get_reqlpa()
int get_reqlpn() {
        int retValue;
        retValue = rand() % NUMOFPAGE;
        return (retValue);
}

// get_ppn_PT(), if hit then returns ppn, else -1
int get_ppn_PT(int lpn) {
        if (pagetable[lpn] >= 0) {
                return (pagetable[lpn]);
        }
        return -1;
}

// get_free_page in physical block
int get_free_page() {
        int i = 0, j = 0;
        char state_tmp;

        for (i = 0; i < NUMOFBLOCK; i++) {
                for (j = 0; j < NUMOFPAGEINBLOCK; j++) {

                        state_tmp = nb[i].pageinB[j].spare[STATE];
                        if (state_tmp == ERASED) {
                                return (i * 4 + j);
                        }
                }
        }
        return -1; // no free page!
}

// write_lpn()
int write_lpn(int lpn, char *buffer) {
        int ppn, blockN, pageN, temp;
        ppn = get_ppn_PT(lpn); // get ppn from the page table
        temp = get_free_page(); // get free ppn, from the physical block

        if (temp >= 0) {
                if (ppn >= 0) {
                        blockN = ppn / NUMOFPAGEINBLOCK;
                        pageN = ppn / NUMOFPAGEINBLOCK;
                        nb[blockN].pageinB[pageN].spare[STATE] = INVALID;
                }

                pagetable[lpn] = temp;
                blockN = temp / NUMOFPAGEINBLOCK;
                pageN = temp % NUMOFPAGEINBLOCK;
                nb[blockN].pageinB[pageN].spare[STATE] = VALID;
                totwritecnt++;
                return 0;
        }
        return 0;
}

// init_block() : init block and pagetable
void init_block(NANDblock *nb) {
        int i = 0, j = 0;
        char tempbuf[] = "INIT DATA";

        nb = (NANDblock *) malloc(NUMOFBLOCK * sizeof(NANDblock));

        for (i = 0; i < NUMOFBLOCK; i++) {
                for (j = 0; j < NUMOFPAGEINBLOCK; j++) {
                        memcpy(nb[i].pageinB[j].data, tempbuf, 512);
                        nb[i].pageinB[j].spare[STATE] = ERASED;
                }
        }
        for (i = 0; i < NUMOFPAGE; i++) {
                pagetable[i] = -1;
        }
}

// display()
void display() {
        int i = 0, j = 0;
        char tmp;
        puts(
                        "--------------------------------------------------------------------------------------------------");
        puts(
                        "-------------------------------------------PHYSICAL MAP-------------------------------------------");
        for (i = 0; i < NUMOFBLOCK; i++) {
                printf("BLOCK %d : \\t", i);
                for (j = 0; j < NUMOFPAGEINBLOCK; j++) {
                        tmp = nb[i].pageinB[j].spare[STATE];
                        if (tmp == VALID)
                                printf("\\t%d\\t[V]\\t\\t", j);
                        else if (tmp == INVALID)
                                printf("\\t%d\\t[I]\\t\\t", j);
                        else if (tmp == ERASED)
                                printf("\\t%d\\t[E]\\t\\t", j);
                        else
                                puts("Error stste!!!");
                }
                printf("\\n");
        }
        puts(
                        "--------------------------------------------------------------------------------------------------");
}

int main(int argc, char *argv[]) {
        int lpn, loop = 1, result;
        char *buffer = {0};

        init_block(nb);

        srand(time(NULL)); // to get random lpn

        while (loop) {
                lpn = get_reqlpn();
                result = write_lpn(lpn, buffer);
                if (totwritecnt == NUMOFPAGE || result < 0) {
                        puts("PHYSICAL PAGES ARE FULL!");
                        break;
                }
        }
        display();
        return 0;
}