example_usage.cpp

/**
 * @file example_usage.cpp
 * @brief Comprehensive example demonstrating Railway Scheduling System library usage
 * 
 * This file provides practical examples of how to use the Advanced Railway Scheduling
 * System library in your own projects. It covers all major components and design patterns.
 */

#include "Railwaysystem.h"
#include <iostream>
#include <vector>
#include <memory>

// Helper function to create time
std::time_t createTime(int hours, int minutes) {
    std::tm timeinfo = {};
    timeinfo.tm_hour = hours;
    timeinfo.tm_min = minutes;
    timeinfo.tm_sec = 0;
    timeinfo.tm_mday = 1;
    timeinfo.tm_mon = 0;
    timeinfo.tm_year = 120;
    return std::mktime(&timeinfo);
}

/**
 * @brief Example 1: Basic Station and Platform Management
 */
void example1_BasicStationManagement() {
    std::cout << "\n=== Example 1: Basic Station Management ===\n";
    
    try {
        // Create stations with different ID types
        std::vector<Station> stations;
        stations.emplace_back("DELHI");      // String ID
        stations.emplace_back("MUMBAI");     // String ID
        
        // Add lines to Delhi station
        auto& delhi = stations[0];
        delhi.addLine("Western Line", 1, 1);
        delhi.addLine("Central Line", 2, 2);
        
        std::cout << "✅ Successfully created stations and added lines\n";
        std::cout << "Delhi Station ID: " << delhi.getStationID() << "\n";
        std::cout << "Number of lines: " << delhi.getLines().size() << "\n";
        
        // Try to schedule a train
        std::time_t departureTime = createTime(14, 30);
        Platform& platform1 = delhi.getLines()[0].getPlatform();
        
        platform1.addStoppage(departureTime);
        std::cout << "✅ Train scheduled successfully at 14:30\n";
        
    } catch (const std::exception& e) {
        std::cerr << "❌ Error: " << e.what() << std::endl;
    }
}

/**
 * @brief Example 2: Train Polymorphism and Different Train Types
 */
void example2_TrainPolymorphism() {
    std::cout << "\n=== Example 2: Train Polymorphism ===\n";
    
    // Create different types of trains
    std::vector<std::shared_ptr<Train>> trains;
    trains.push_back(std::make_shared<ExpressTrain>("EXP001", "Rajdhani Express"));
    trains.push_back(std::make_shared<LocalTrain>("LOC001", "Mumbai Local"));
    trains.push_back(std::make_shared<HighSpeedTrain>("HST001", "Vande Bharat"));
    trains.push_back(std::make_shared<FreightTrain>("FRT001", "Cargo Express", 750.0));
    
    // Demonstrate polymorphic behavior
    for (const auto& train : trains) {
        std::cout << "\n--- " << train->getTrainName() << " ---\n";
        train->displayTrainInfo();
        std::cout << "100km fare: ₹" << train->calculateTicketPrice(100.0) << "\n";
        std::cout << "Stopping time: " << train->getStoppingTime() << " minutes\n";
    }
}

/**
 * @brief Example 3: Notification System (Observer Pattern)
 */
void example3_NotificationSystem() {
    std::cout << "\n=== Example 3: Notification System ===\n";
    
    // Create notification center
    auto notificationCenter = std::make_shared<NotificationCenter>();
    
    // Add different types of observers
    notificationCenter->addObserver(
        std::make_shared<PassengerNotification>("P001")
    );
    notificationCenter->addObserver(
        std::make_shared<StationMasterNotification>("DELHI")
    );
    notificationCenter->addObserver(
        std::make_shared<MaintenanceNotification>()
    );
    
    std::cout << "Sending various notifications...\n";
    
    // Send different types of notifications
    notificationCenter->notifyDelayUpdate("EXP001", 15);
    notificationCenter->notifyPlatformChange("LOC001", 2, 3);
    notificationCenter->notifyCancellation("FRT001", "Engine maintenance required");
    notificationCenter->notifyMaintenanceAlert("Platform 1", "Signal system needs attention");
}

/**
 * @brief Example 4: Scheduling Strategies (Strategy Pattern)
 */
void example4_SchedulingStrategies() {
    std::cout << "\n=== Example 4: Scheduling Strategies ===\n";
    
    // Create platform and trains
    Platform platform(1);
    std::vector<std::shared_ptr<Train>> trains;
    trains.push_back(std::make_shared<ExpressTrain>("EXP001", "Express Train"));
    trains.push_back(std::make_shared<LocalTrain>("LOC001", "Local Train"));
    trains.push_back(std::make_shared<HighSpeedTrain>("HST001", "High Speed Train"));
    
    // Test different scheduling strategies
    std::vector<std::unique_ptr<SchedulingStrategy>> strategies;
    strategies.push_back(std::unique_ptr<SchedulingStrategy>(new FCFSScheduling()));
    strategies.push_back(std::unique_ptr<SchedulingStrategy>(new PriorityScheduling()));
    strategies.push_back(std::unique_ptr<SchedulingStrategy>(new OptimalScheduling()));
    
    for (auto& strategy : strategies) {
        std::cout << "\nTesting Strategy: " << strategy->getStrategyName() << "\n";
        
        SchedulingContext context(std::move(strategy));
        bool success = context.executeScheduling(platform, trains);
        std::cout << "Result: " << (success ? "✅ Success" : "❌ Failed") << "\n";
    }
}

/**
 * @brief Example 5: Passenger Management and Dynamic Pricing
 */
void example5_PassengerManagement() {
    std::cout << "\n=== Example 5: Passenger Management ===\n";
    
    PassengerManagementSystem pms;
    
    // Register passengers
    std::cout << "Registering passengers...\n";
    bool success1 = pms.registerPassenger("P001", "John Doe", "9876543210", "john@email.com");
    bool success2 = pms.registerPassenger("P002", "Jane Smith", "9876543211", "jane@email.com");
    
    std::cout << "P001 registration: " << (success1 ? "✅ Success" : "❌ Failed") << "\n";
    std::cout << "P002 registration: " << (success2 ? "✅ Success" : "❌ Failed") << "\n";
    
    // Book ticket with regular pricing
    std::cout << "\n--- Booking with Regular Pricing ---\n";
    std::time_t journeyDate = createTime(14, 30);
    std::string ticketID1 = pms.bookTicket(
        "P001", "EXP001", "DELHI", "MUMBAI", 
        journeyDate, Ticket::TicketClass::AC_2_TIER, 1000.0
    );
    
    if (!ticketID1.empty()) {
        std::cout << "✅ Ticket booked: " << ticketID1 << "\n";
        pms.confirmTicket(ticketID1);
    }
    
    // Switch to dynamic pricing
    std::cout << "\n--- Switching to Dynamic Pricing ---\n";
    pms.setPricingStrategy(
        std::unique_ptr<PricingStrategy>(new DynamicPricing())
    );
    
    std::string ticketID2 = pms.bookTicket(
        "P002", "HST001", "DELHI", "BANGALORE", 
        journeyDate, Ticket::TicketClass::AC_1_TIER, 2000.0
    );
    
    if (!ticketID2.empty()) {
        std::cout << "✅ Ticket booked with dynamic pricing: " << ticketID2 << "\n";
    }
    
    // Display booking summary
    std::cout << "\n--- Booking Summary ---\n";
    auto ticket1 = pms.findTicket(ticketID1);
    auto ticket2 = pms.findTicket(ticketID2);
    
    if (ticket1) ticket1->displayTicket();
    if (ticket2) ticket2->displayTicket();
    
    std::cout << "Total System Revenue: ₹" << pms.getTotalRevenue() << "\n";
}

/**
 * @brief Example 6: Performance Analytics (Singleton Pattern)
 */
void example6_PerformanceAnalytics() {
    std::cout << "\n=== Example 6: Performance Analytics ===\n";
    
    // Get singleton instance
    auto analytics = PerformanceAnalytics::getInstance();
    
    // Record sample performance data
    std::cout << "Recording performance data...\n";
    
    analytics->recordDelay("EXP001", 10);
    analytics->recordDelay("EXP001", 15);
    analytics->recordDelay("LOC001", 5);
    analytics->recordDelay("HST001", 3);
    
    analytics->recordStationTraffic("DELHI");
    analytics->recordStationTraffic("DELHI");
    analytics->recordStationTraffic("MUMBAI");
    
    analytics->recordRevenue("DELHI-MUMBAI", 25000.0);
    analytics->recordRevenue("DELHI-BANGALORE", 35000.0);
    
    analytics->recordPlatformUtilization("P1", 85.5);
    analytics->recordPlatformUtilization("P2", 72.3);
    
    analytics->recordCancellation("FRT001");
    
    std::cout << "✅ Data recorded successfully\n";
    
    // Generate comprehensive report
    analytics->generatePerformanceReport();
    
    // Get specific metrics
    std::cout << "\n--- Quick Metrics ---\n";
    std::cout << "System Average Delay: " << analytics->getSystemWideAverageDelay() << " minutes\n";
    std::cout << "Busiest Station: " << analytics->getBusiestStation() << "\n";
    std::cout << "Total Revenue: ₹" << analytics->getTotalRevenue() << "\n";
}

/**
 * @brief Example 7: Route Management (Composite Pattern)
 */
void example7_RouteManagement() {
    std::cout << "\n=== Example 7: Route Management ===\n";
    
    RouteManager routeManager;
    
    // Create route segments
    auto segment1 = std::make_shared<RouteSegment>("DELHI", "GURGAON", 30.0);
    auto segment2 = std::make_shared<RouteSegment>("GURGAON", "FARIDABAD", 25.0);
    auto segment3 = std::make_shared<RouteSegment>("FARIDABAD", "MATHURA", 45.0);
    auto segment4 = std::make_shared<RouteSegment>("MATHURA", "AGRA", 60.0);
    
    // Create complete routes
    auto northernRoute = std::make_shared<CompleteRoute>("Delhi-Agra Express Route");
    northernRoute->addSegment(segment1);
    northernRoute->addSegment(segment2);
    northernRoute->addSegment(segment3);
    northernRoute->addSegment(segment4);
    
    // Add to route manager
    routeManager.addRoute(northernRoute);
    
    // Add distance matrix for pathfinding
    routeManager.addDistance("DELHI", "GURGAON", 30.0);
    routeManager.addDistance("GURGAON", "FARIDABAD", 25.0);
    routeManager.addDistance("FARIDABAD", "MATHURA", 45.0);
    routeManager.addDistance("MATHURA", "AGRA", 60.0);
    
    // Display route information
    northernRoute->displayRoute();
    
    // Test pathfinding
    auto path = routeManager.findShortestPath("DELHI", "GURGAON");
    if (!path.empty()) {
        std::cout << "Shortest path found: ";
        for (const auto& station : path) {
            std::cout << station << " ";
        }
        std::cout << std::endl;
    }
    
    // Calculate route distance
    std::vector<std::string> testRoute = {"DELHI", "GURGAON", "FARIDABAD"};
    double distance = routeManager.calculateRouteDistance(testRoute);
    if (distance > 0) {
        std::cout << "Route distance (Delhi-Gurgaon-Faridabad): " << distance << " km\n";
    }
}

/**
 * @brief Example 8: Delay Management System
 */
void example8_DelayManagement() {
    std::cout << "\n=== Example 8: Delay Management ===\n";
    
    // Create notification center for delay alerts
    auto notificationCenter = std::make_shared<NotificationCenter>();
    notificationCenter->addObserver(
        std::make_shared<StationMasterNotification>("CONTROL_ROOM")
    );
    
    DelayManagementSystem delaySystem(notificationCenter);
    
    // Report various types of delays
    std::cout << "Reporting delays...\n";
    
    std::string incident1 = delaySystem.reportDelay(
        "EXP001", DelayCategory::TECHNICAL_FAILURE, 
        20, "Engine overheating detected"
    );
    
    std::string incident2 = delaySystem.reportDelay(
        "LOC001", DelayCategory::WEATHER, 
        10, "Heavy rainfall affecting visibility"
    );
    
    std::string incident3 = delaySystem.reportDelay(
        "HST001", DelayCategory::SIGNAL_PROBLEM, 
        5, "Signal malfunction at junction"
    );
    
    // Display current active delays
    delaySystem.displayActiveDelays();
    
    // Update a delay
    std::cout << "\nUpdating delay for incident " << incident1 << "...\n";
    delaySystem.updateDelay(incident1, 25);
    
    // Resolve a delay
    std::cout << "Resolving incident " << incident2 << "...\n";
    delaySystem.resolveDelay(incident2);
    
    // Show analytics
    delaySystem.displayDelayAnalytics();
}

/**
 * @brief Main function demonstrating all examples
 */
int main() {
    std::cout << "🚂 Advanced Railway Scheduling System - Usage Examples\n";
    std::cout << "=====================================================\n";
    
    try {
        example1_BasicStationManagement();
        example2_TrainPolymorphism();
        example3_NotificationSystem();
        example4_SchedulingStrategies();
        example5_PassengerManagement();
        example6_PerformanceAnalytics();
        example7_RouteManagement();
        example8_DelayManagement();
        
        std::cout << "\n🎉 All examples completed successfully!\n";
        std::cout << "\nNext Steps:\n";
        std::cout << "1. Study the source code in src/ directory\n";
        std::cout << "2. Run the advanced demo: ./build/bin/advanced_railway_app\n";
        std::cout << "3. Check the comprehensive README.md for detailed documentation\n";
        std::cout << "4. Explore individual components for your specific use case\n";
        
    } catch (const std::exception& e) {
        std::cerr << "❌ Error in examples: " << e.what() << std::endl;
        return 1;
    }
    
    return 0;
}

/**
 * @brief Compilation Instructions:
 * 
 * To compile and run this example:
 * 
 * g++ -std=c++11 -Wall -Wextra -o example_usage example_usage.cpp \
 *     src/Platform.cpp src/SchedulingStrategy.cpp src/Station.cpp src/Line.cpp
 * 
 * ./example_usage
 * 
 * Or use the Makefile:
 * make clean
 * g++ -std=c++11 -o build/bin/example_usage example_usage.cpp src/*.cpp
 * ./build/bin/example_usage
 */