// Optimal BFS web crawler with hash table
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_URLS 1000
#define MAX_URL_LEN 200
#define HASH_SIZE 1009

typedef struct HashNode {
    char url[MAX_URL_LEN];
    struct HashNode* next;
} HashNode;

typedef struct {
    HashNode* table[HASH_SIZE];
} HashSet;

unsigned int hash(char* url) {
    unsigned int hash = 5381;
    for (int i = 0; url[i]; i++) {
        hash = ((hash << 5) + hash) + url[i];
    }
    return hash % HASH_SIZE;
}

int hashset_contains(HashSet* set, char* url) {
    unsigned int index = hash(url);
    HashNode* node = set->table[index];
    while (node) {
        if (strcmp(node->url, url) == 0) return 1;
        node = node->next;
    }
    return 0;
}

void hashset_add(HashSet* set, char* url) {
    if (hashset_contains(set, url)) return;
    unsigned int index = hash(url);
    HashNode* node = malloc(sizeof(HashNode));
    strcpy(node->url, url);
    node->next = set->table[index];
    set->table[index] = node;
}

char* getHostname(char* url) {
    char* start = strstr(url, "://") + 3;
    char* end = strchr(start, '/');
    int len = end ? (end - start) : strlen(start);
    
    char* hostname = malloc(len + 1);
    strncpy(hostname, start, len);
    hostname[len] = '\0';
    return hostname;
}

char** crawl(char* startUrl, HtmlParser* parser, int* returnSize) {
    HashSet visited = {0};
    char queue[MAX_URLS][MAX_URL_LEN];
    int front = 0, rear = 0;
    
    strcpy(queue[rear++], startUrl);
    hashset_add(&visited, startUrl);
    char* startHostname = getHostname(startUrl);
    
    while (front < rear) {
        char* currentUrl = queue[front++];
        
        char** urls = getUrls(parser, currentUrl);
        int urlCount = getUrlCount(parser, currentUrl);
        
        for (int i = 0; i < urlCount; i++) {
            char* hostname = getHostname(urls[i]);
            if (!hashset_contains(&visited, urls[i]) && strcmp(hostname, startHostname) == 0) {
                hashset_add(&visited, urls[i]);
                strcpy(queue[rear++], urls[i]);
            }
            free(hostname);
        }
    }
    
    // Convert HashSet to array
    char** result = malloc(MAX_URLS * sizeof(char*));
    *returnSize = 0;
    for (int i = 0; i < HASH_SIZE; i++) {
        HashNode* node = visited.table[i];
        while (node) {
            result[*returnSize] = malloc(strlen(node->url) + 1);
            strcpy(result[*returnSize], node->url);
            (*returnSize)++;
            node = node->next;
        }
    }
    
    free(startHostname);
    return result;
}