main.cpp

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <random> // Fix #5: Using modern <random> engine
#include <iomanip>
#include <algorithm>
#include <set>
#include "analytics_engine.h" // Integrated isolated analytics header
#include "url_database.h"
#include "semaphore.h"
// ============================================================================
// 1. DATA STRUCTURES & CONFIGURATIONS
// ============================================================================

struct URLData {
    std::string original_url;
    std::string short_code;
    std::string alias;
    int clicks = 0;
    std::string qr_code;
    std::chrono::system_clock::time_point expires_at;
};


// ============================================================================
// 3. SMART URL HOSTING PLATFORM ENGINE
// ============================================================================

class SmartURLPlatform {
private:
    std::unordered_map<std::string, URLData> db;
    std::unordered_map<std::string, std::string> alias_map;
    std::mutex db_mutex;
    Semaphore connection_pool;
    
    // Memory and OS Simulation Profilers
    std::vector<std::string> memory_access_history;
    std::vector<ProcessMetrics> simulated_cpu_queue;
    int pid_counter = 1000;

    // Deadlock verification resources
    std::mutex microservice_A_lock;
    std::mutex microservice_B_lock;

    // Fix #5: Replaced rand() with thread-safe high-quality Mersenne Twister engine
    std::mt19937 rng;

    std::string generateRandomCode() {
        const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        std::string code = "";
        std::uniform_int_distribution<int> dist(0, sizeof(charset) - 2);
        for (int i = 0; i < 6; ++i) {
            code += charset[dist(rng)];
        }
        return code;
    }

public:
    SmartURLPlatform() : connection_pool(5), rng(std::random_device{}()) {}

    void createShortURL(std::string original, std::string custom_alias = "", int expiry_seconds = 3600) {
        connection_pool.wait();
        std::lock_guard<std::mutex> lock(db_mutex);

        // Fix #3: Duplicate Custom Alias check validation
        if (!custom_alias.empty() && alias_map.count(custom_alias)) {
            std::cout << " [ERROR] Alias \"" << custom_alias << "\" already exists! Request rejected.\n";
            connection_pool.notify();
            return;
        }

        std::uniform_int_distribution<int> arrival_dist(0, 2);
        std::uniform_int_distribution<int> burst_dist(2, 6);

        int arrival = simulated_cpu_queue.empty() ? 0 : simulated_cpu_queue.back().arrival_time + arrival_dist(rng);
        int burst = burst_dist(rng);
        simulated_cpu_queue.push_back({++pid_counter, "CREATE", burst, burst, arrival, 0, 0});

        std::string code;
        if (custom_alias.empty()) {
            // Fix #2: Loop execution to eliminate short-code collisions
            do {
                code = generateRandomCode();
            } while (db.find(code) != db.end());
        } else {
            code = custom_alias;
        }
        
        URLData url;
        url.original_url = original;
        url.short_code = code;
        url.alias = custom_alias;
        url.qr_code = "[QR Code Matrix for " + code + "]";
        url.expires_at = std::chrono::system_clock::now() + std::chrono::seconds(expiry_seconds);

        db[code] = url;
        if (!custom_alias.empty()) {
            alias_map[custom_alias] = code;
        }
        
        // Fix #7: Cap memory log traces to avoid long-term leakage footprints
        if (memory_access_history.size() >= 1000) {
            memory_access_history.erase(memory_access_history.begin());
        }
        memory_access_history.push_back(code);
        
        connection_pool.notify();
    }

    std::string accessURL(std::string code) {
        connection_pool.wait();
        std::lock_guard<std::mutex> lock(db_mutex);

        std::uniform_int_distribution<int> arrival_dist(0, 2);
        std::uniform_int_distribution<int> burst_dist(1, 3);

        int arrival = simulated_cpu_queue.empty() ? 0 : simulated_cpu_queue.back().arrival_time + arrival_dist(rng);
        int burst = burst_dist(rng);
        simulated_cpu_queue.push_back({++pid_counter, "REDIRECT", burst, burst, arrival, 0, 0});

        if (memory_access_history.size() >= 1000) {
            memory_access_history.erase(memory_access_history.begin());
        }
        memory_access_history.push_back(code);

        if (alias_map.find(code) != alias_map.end()) {
            code = alias_map[code];
        }

        if (db.find(code) != db.end()) {
            // Fix #6: Evict expired records completely instead of leaving stale garbage entries
            if (std::chrono::system_clock::now() > db[code].expires_at) {
                if (!db[code].alias.empty()) {
                    alias_map.erase(db[code].alias);
                }
                db.erase(code);
                connection_pool.notify();
                return "ERROR: URL Expired and Evicted from System Storage!";
            }
            db[code].clicks++;
            connection_pool.notify();
            return db[code].original_url;
        }
        
        connection_pool.notify();
        return "404 Not Found";
    }

    // Fix #6: Background maintenance module to target and remove remaining expired urls
    void cleanExpiredURLs() {
        std::lock_guard<std::mutex> lock(db_mutex);
        auto now = std::chrono::system_clock::now();
        for (auto it = db.begin(); it != db.end();) {
            if (now > it->second.expires_at) {
                if (!it->second.alias.empty()) {
                    alias_map.erase(it->second.alias);
                }
                it = db.erase(it);
            } else {
                ++it;
            }
        }
    }

    // Fix #1: Elimination of random background thread lock hangs using std::scoped_lock
    void simulateDeadlockCondition() {
        std::cout << "\n=== [DEADLOCK MANAGEMENT SIMULATION ENGINE] ===\n";
        
        auto worker1 = [this]() {
            // std::scoped_lock locks all resources safely using a deadlock-avoidance algorithm
            std::scoped_lock lock(microservice_A_lock, microservice_B_lock);
            std::cout << "[Thread 1] Safely acquired Service A and B simultaneously.\n";
        };

        auto worker2 = [this]() {
            std::scoped_lock lock(microservice_B_lock, microservice_A_lock);
            std::cout << "[Thread 2] Safely acquired Service B and A simultaneously.\n";
        };

        std::cout << "Starting resource workers using safe variadic std::scoped_lock configurations...\n";
        std::thread t1(worker1);
        std::thread t2(worker2);
        
        t1.join();
        t2.join();
        std::cout << "[DASHBOARD CHECK] Multithreading operations running clean without mutex-deadlock freezes!\n";
    }

    void displayDashboard() {
        std::lock_guard<std::mutex> lock(db_mutex);
        std::cout << "\n=======================================================\n";
        std::cout << "                 🚀 CPU & PLATFORM DASHBOARD          \n";
        std::cout << "=======================================================\n";
        std::cout << " Active Mock Requests Logged: " << simulated_cpu_queue.size() << "\n";
        std::cout << " Live Database Mapped Keys  : " << db.size() << "\n";
        std::cout << " Main CPU Utilization       : " << (simulated_cpu_queue.empty() ? 0 : 87.4) << " %\n";
        std::cout << " Thread State Queue Status  : IDLE/RUNNING OK\n\n";

        std::cout << "Link Analytics Log:\n";
        for (const auto& [key, data] : db) {
            std::cout << " - Short Code: [" << key << "] -> " << data.original_url 
                      << " | Total Hits: " << data.clicks << " | QR Graphic: " << data.qr_code << "\n";
        }
        std::cout << "=======================================================\n";
        
        // Pass control blocks directly down into the isolated analytics pipeline
        if(!simulated_cpu_queue.empty()) {
            AnalyticsEngine::computeSchedulingAlgorithms(simulated_cpu_queue);
        }
        if(!memory_access_history.empty()) {
            AnalyticsEngine::computePageReplacements(memory_access_history, 3);
        }
    }
};

// ============================================================================
// 4. MAIN SYSTEM SYSTEM ENTRYPOINT
// ============================================================================

int main() {
    SmartURLPlatform platform;

    std::cout << "Initializing SmartURL Secure System Infrastructure Threads...\n";

    // Simulate multi-threaded user environment traffic via concurrent lambdas
    std::thread user1(&SmartURLPlatform::createShortURL, &platform, "https://google.com", "goog", 3600);
    std::thread user2(&SmartURLPlatform::createShortURL, &platform, "https://github.com", "", 3600);
    std::thread user3(&SmartURLPlatform::createShortURL, &platform, "https://stackoverflow.com", "so", 3600);

    user1.join();
    user2.join();
    user3.join();

    // Trigger explicit testing for custom alias collision prevention
    std::cout << "\n--- Testing Alias Collision Protection ---\n";
    platform.createShortURL("https://microsoft.com", "goog", 3600);

    // Trigger parallel redirection load
    std::thread client1([&]() { platform.accessURL("goog"); });
    std::thread client2([&]() { platform.accessURL("so"); });
    std::thread client3([&]() { platform.accessURL("goog"); });

    client1.join();
    client2.join();
    client3.join();

    // Run proactive maintenance cleaner sweep loop
    platform.cleanExpiredURLs();

    // Fire Analytics, UI Metrics Dashboard, and Deadlock Modules
    platform.displayDashboard();
    platform.simulateDeadlockCondition();

    std::cout << "\nTerminating Engine System Execution Thread Pool Safely. Done!\n";
    return 0;
}