#include "building.h"
#include <stdlib.h>
#include <stdio.h>
#include <wchar.h>

#define WALL '1'
#define DOOR '2'
#define SPACE '0'
#define VISITED '3'

void freeRoom(Room * room){
Room * next;
while (room != NULL) {
   next = room->nextRoom;
   free(room);
   room = next;
}
}

/**
* You guessed it … this procedure should free up all
* dynamically-allocated memory so that valgrind shows no memory leaks nor errors.
* @param bld
*/
void freeEverything(Building * bld) {
int i;
for (i = 0; i < NUM_FLOORS; i++) {
   free(bld->floors[i].doors);
}
freeRoom(bld->hallways);
freeRoom(bld->labs);
freeRoom(bld->meetingRooms);
freeRoom(bld->offices);
freeRoom(bld->storageRooms);

};

void traceRoom(Room * room, char grid[HEIGHT][HEIGHT],
   int row, int col, FloorPlan * plan) {
// out of bound
if (row < 0 || row >= HEIGHT
         || col < 0 || col >= HEIGHT) {
   return;
}

Door * doors = plan->doors;
switch (grid[row][col]) {
   case SPACE:
   {
         /**
         * As you trace out the room, increase the counter for the room
         * size and so that upon completion, the recursive
         * function has set the room size to the correct value.
         */
         room->size++;
         grid[row][col] = VISITED;
         /**
         * To trace out a room recursively, start at some (row, col) location
         * (i.e., the one that you
         * found the ‘0’ at). Then recursively traverse the grid up,
         * down, left and right.
         */
         traceRoom(room, grid, row + 1, col, plan);
         traceRoom(room, grid, row - 1, col, plan);
         traceRoom(room, grid, row, col + 1, plan);
         traceRoom(room, grid, row, col - 1, plan);
   }
         break;
   case DOOR:
   {
         /**
         * Also, when you encounter a door, you should:
         */
         // increase the door count for the room, and
         room->numDoors++;
         /**
         * find the door in the building at this location and set
         * this room as one of its two rooms.
         */
         /**
         * It makes sense to use a FOR loop here to check ALL of
         * the doors in the building to determine which one matches the
         * location you are at while tracing. When the tracing procedure
         * has completed, all doors on that floor should have their
         * openFromRoom and openToRoom set accordingly. It does not
         * matter which room is the openToRoom or openFromRoom …
         * the order is unimportant.Note that there may be some doors
         * that are on the edge of the building. These doors will have
         * only one of these set … it doesn’t matter which one you set.
         */
         int i;
         for (i = 0; i < (int) plan->numDoors; i++) {
            if (doors[i].col == (unsigned char) col
                     && doors[i].row == (unsigned char) row) {
               if (doors[i].openFromRoom == NULL) {
                     doors[i].openFromRoom = room;
               } else {
                     doors[i].openToRoom = room;
               }
               break;
            }
         }
   }
         break;
   default:
         /**
         * The recursion stopping case is when you are at a non-‘0’ location.
         */
         break;
}
}

/**
* This procedure assumes that all the doors have been found previously.
* It takes a building pointer and a floor number as parameters. It must
* then go through the floorPlan’s grid for that floor number to identify
* its rooms. You MUST go through the grid from left to right (starting at
* the top row) … to search for a grid location that is ‘0’. This will be a
* starting point for tracing out a room. When you find a ‘0’, you should
* dynamically-allocate a new room with 0 size and 0 numDoors. You should
* add this room to the floor plan’s linked-list of rooms (i.e., roomList).
* You MUST then call a recursive procedure (of your own creation) that
* will trace out the remainder of the room. To trace out a room recursively,
* start at some (row, col) location (i.e., the one that you found the ‘0’ at).
* Then recursively traverse the grid up, down, left and right. The recursion
* stopping case is when you are at a non-‘0’ location. Make sure to mark
* visited locations with a character that is not ‘0’, ‘1’ or ‘2’.
* As you trace out the room, increase the counter for the room size and
* so that upon completion, the recursive function has set the room size
* to the correct value. Also, when you encounter a door, you should:
* ▪ increase the door count for the room, and
* ▪ find the door in the building at this location and set this room as one
* of its two rooms. That is, each door keeps track of the two rooms that
* it joins (i.e., openFromRoom and openToRoom). You should find out
* which of those two values is NULL (both may be at first)
* and then set that to be this room. It makes sense to use a FOR
* loop here to check ALL of the doors in the building to determine which
* one matches the location you are at while tracing. When the tracing
* procedure has completed, all doors on that floor should have their

Fill a 3x5 array with random numbers ranging from 0 to 10000. Then...