#include <stdio.h>
#include <stdlib.h>
#include <limits.h> // For INT_MAX

// Structure for a memory block
typedef struct Block {
    int id;          // Block ID (optional, can use address for uniqueness)
    int size;        // Size of the block
    int allocated;   // 0 if free, 1 if allocated
    int process_id;  // ID of process allocated to this block (-1 if free)
    struct Block *next; // Pointer to the next block in the list
    struct Block *prev; // Pointer to the previous block in the list (for potential merging)
} Block;

// Global head of the memory block linked list
Block *memory_head = NULL;

// Function to create a new block node
Block* create_block(int id, int size, int allocated, int process_id) {
    Block *new_block = (Block*)malloc(sizeof(Block));
    if (!new_block) {
        perror("Failed to allocate memory for block");
        exit(EXIT_FAILURE);
    }
    new_block->id = id;
    new_block->size = size;
    new_block->allocated = allocated;
    new_block->process_id = process_id;
    new_block->next = NULL;
    new_block->prev = NULL;
    return new_block;
}

// Function to initialize the memory list with one large free block
void initialize_memory(int total_size) {
    if (memory_head != NULL) {
         // Simple cleanup for re-initialization (more robust needed for general use)
         Block *current = memory_head;
         Block *next_node;
         while(current != NULL) {
             next_node = current->next;
             free(current);
             current = next_node;
         }
         memory_head = NULL; // Reset head
    }
    memory_head = create_block(0, total_size, 0, -1); // ID 0, size, free, no process
}

// Function to display the current state of memory blocks
void display_memory() {
    Block *current = memory_head;
    printf("Memory Blocks:\n");
    printf("----------------------------------------------------\n");
    printf("| ID | Size      | Status    | Process ID |\n");
    printf("----------------------------------------------------\n");
    while (current != NULL) {
        printf("| %-2d | %-9d | %-9s | %-10d |\n",
               current->id,
               current->size,
               current->allocated ? "Allocated" : "Free",
               current->allocated ? current->process_id : -1);
        current = current->next;
    }
    printf("----------------------------------------------------\n\n");
}

// Function to allocate memory using First Fit strategy
int allocate_first_fit(int process_id, int required_size) {
    Block *current = memory_head;
    Block *best_block = NULL;

    // Find the first free block that is large enough
    while (current != NULL) {
        if (!current->allocated && current->size >= required_size) {
            best_block = current;
            break; // First fit found
        }
        current = current->next;
    }

    // If a suitable block is found
    if (best_block != NULL) {
        // Check if splitting is necessary (and worthwhile, e.g., remaining > 0)
        if (best_block->size > required_size) {
            // Create a new block for the remaining free space
            int remaining_size = best_block->size - required_size;
            // For simplicity, assigning next available ID - needs better management in real system
            int new_block_id = best_block->id + 1; // simplistic ID assignment
            Block *new_free_block = create_block(new_block_id, remaining_size, 0, -1);

            // Update the allocated block
            best_block->size = required_size;
            best_block->allocated = 1;
            best_block->process_id = process_id;

            // Insert the new free block into the list
            new_free_block->next = best_block->next;
            new_free_block->prev = best_block;
            if (best_block->next != NULL) {
                best_block->next->prev = new_free_block;
            }
            best_block->next = new_free_block;

            // Renumber subsequent block IDs (basic approach)
            Block* temp = new_free_block->next;
            int current_id = new_block_id + 1;
            while (temp != NULL) {
                temp->id = current_id++;
                temp = temp->next;
            }

        } else { // Exact fit or minimal leftover space (allocate the whole block)
            best_block->allocated = 1;
            best_block->process_id = process_id;
        }
        printf("Process %d allocated %d units using First Fit in Block %d.\n", process_id, required_size, best_block->id);
        return 1; // Allocation successful
    } else {
        printf("Process %d (size %d) could not be allocated using First Fit.\n", process_id, required_size);
        return 0; // Allocation failed
    }
}


// Function to allocate memory using Best Fit strategy
int allocate_best_fit(int process_id, int required_size) {
    Block *current = memory_head;
    Block *best_block = NULL;
    int min_waste = INT_MAX;

    // Find the smallest free block that is large enough
    while (current != NULL) {
        if (!current->allocated && current->size >= required_size) {
            int waste = current->size - required_size;
            if (waste < min_waste) {
                min_waste = waste;
                best_block = current;
            }
        }
        current = current->next;
    }

    // If a suitable block is found
    if (best_block != NULL) {
         // Check if splitting is necessary (and worthwhile, e.g., remaining > 0)
        if (best_block->size > required_size) {
            // Create a new block for the remaining free space
            int remaining_size = best_block->size - required_size;
            int new_block_id = best_block->id + 1; // simplistic ID assignment
            Block *new_free_block = create_block(new_block_id, remaining_size, 0, -1);

            // Update the allocated block
            best_block->size = required_size;
            best_block->allocated = 1;
            best_block->process_id = process_id;

            // Insert the new free block into the list
            new_free_block->next = best_block->next;
            new_free_block->prev = best_block;
            if (best_block->next != NULL) {
                best_block->next->prev = new_free_block;
            }
            best_block->next = new_free_block;

            // Renumber subsequent block IDs (basic approach)
             Block* temp = new_free_block->next;
            int current_id = new_block_id + 1;
            while (temp != NULL) {
                temp->id = current_id++;
                temp = temp->next;
            }

        } else { // Exact fit (allocate the whole block)
            best_block->allocated = 1;
            best_block->process_id = process_id;
        }
        printf("Process %d allocated %d units using Best Fit in Block %d.\n", process_id, required_size, best_block->id);
        return 1; // Allocation successful
    } else {
        printf("Process %d (size %d) could not be allocated using Best Fit.\n", process_id, required_size);
        return 0; // Allocation failed
    }
}

// Function to free all allocated memory for the linked list
void cleanup_memory() {
    Block *current = memory_head;
    Block *next_node;
    while (current != NULL) {
        next_node = current->next;
        free(current);
        current = next_node;
    }
    memory_head = NULL;
}


int main() {
    int total_memory;
    int num_processes;
    int *process_sizes = NULL; // Dynamically allocated array for process sizes
    int i;

    // --- Input ---
    printf("Enter the total size of memory: ");
    scanf("%d", &total_memory);
    if (total_memory <= 0) {
        printf("Invalid memory size.\n");
        return 1;
    }

    printf("Enter the number of processes: ");
    scanf("%d", &num_processes);
    if (num_processes <= 0) {
        printf("Invalid number of processes.\n");
        return 1;
    }

    // Dynamically allocate array for process sizes
    process_sizes = (int*)malloc(num_processes * sizeof(int));
    if (!process_sizes) {
        perror("Failed to allocate memory for process sizes");
        return 1;
    }

    printf("Enter the size required for each process:\n");
    for (i = 0; i < num_processes; i++) {
        printf("Process %d size: ", i + 1);
        scanf("%d", &process_sizes[i]);
        if (process_sizes[i] <= 0) {
            printf("Invalid process size. Please enter a positive value.\n");
            free(process_sizes);
            return 1;
        }
    }
    printf("\n");


    // --- First Fit Simulation ---
    printf("--- First Fit Allocation ---\n");
    initialize_memory(total_memory);
    printf("Initial Memory State:\n");
    display_memory();

    for (i = 0; i < num_processes; i++) {
        allocate_first_fit(i + 1, process_sizes[i]); // Process IDs starting from 1
        display_memory(); // Show state after each allocation attempt
    }
    printf("Final Memory State after First Fit:\n");
    display_memory();


    // --- Best Fit Simulation ---
    printf("\n--- Best Fit Allocation ---\n");
    initialize_memory(total_memory); // Re-initialize memory for a fresh start
    printf("Initial Memory State:\n");
    display_memory();

    for (i = 0; i < num_processes; i++) {
        allocate_best_fit(i + 1, process_sizes[i]); // Process IDs starting from 1
        display_memory(); // Show state after each allocation attempt
    }
    printf("Final Memory State after Best Fit:\n");
    display_memory();

    // --- Cleanup ---
    free(process_sizes); // Free the dynamically allocated process sizes array
    cleanup_memory(); // Free the memory blocks linked list

    return 0;
}