main.cpp

/**
 * @file main.cpp
 * @brief Console demo entry point for the IRCTC Railway Reservation System.
 */

/**
 * @mainpage IRCTC Railway Reservation System
 *
 * @section intro Overview
 * This project is a simplified IRCTC-style railway reservation demo which
 * showcases basic object-oriented design principles, including separation of
 * concerns, use of services, strategies, and factories.
 *
 * @section structure Project Structure
 * - Root files:
 *   - main.cpp – demo entry point
 *   - Makefile – build script for the executable
 *   - Doxyfile – configuration file for generating this documentation
 *   - README.md – quick project description and usage
 * - include/ – public headers (interfaces and domain models)
 *   - Admin.h, User.h, Train.h, Ticket.h
 *   - TrainDatabase.h, TrainService.h, BookingService.h
 *   - Payment.h, PaymentFactory.h, PaymentService.h
 *   - FareStrategy.h, SimpleFareStrategy.h
 *   - CardPayment.h, NetBankingPayment.h, UpiPayment.h
 * - src/ – implementations of the headers
 * - uml/ – UML diagrams (use-case, class, sequence, activity)
 *
 * @section build_run Building and Running
 * From the project root:
 * - To build the program using the provided Makefile:
 *   - On Linux/macOS: make
 *   - On Windows (with make installed, e.g., via MinGW/MSYS): make
 * - This will produce the executable (for example irctc or irctc.exe).
 *
 * To run the demo after a successful build:
 * - On Linux/macOS: ./irctc
 * - On Windows: run irctc.exe from a terminal or by double-clicking it.
 *
 * @section docs Generating Documentation
 * - Ensure Doxygen is installed.
 * - From the project root, run: doxygen Doxyfile
 *
 * @section authors Authors
 * - Lokesh
 * - Raghunandan
 * - Prateek
 * - Mahek
 * - Rishi
 */

#include <iostream>
#include <memory>
#include <vector>
#include <limits>

#include "User.h"
#include "Admin.h"
#include "Train.h"
#include "Ticket.h"
#include "TrainDatabase.h"
#include "TrainService.h"
#include "PaymentFactory.h"
#include "PaymentService.h"
#include "SimpleFareStrategy.h"
#include "BookingService.h"

void seedTrains(TrainService& trainService) {
    auto t1 = std::make_shared<Train>(
        1, "Rajdhani Express", "Delhi", "Mumbai", "18:00", "08:00", 200, 1500.0);
    auto t2 = std::make_shared<Train>(
        2, "Duronto Express", "Delhi", "Mumbai", "20:00", "10:00", 150, 1800.0);
    auto t3 = std::make_shared<Train>(
        3, "Shatabdi Express", "Delhi", "Chandigarh", "07:00", "10:00", 100, 800.0);

    trainService.addTrain(t1);
    trainService.addTrain(t2);
    trainService.addTrain(t3);
}

int main() {
    std::cout << "=== IRCTC Railway Reservation System (Interactive Demo) ===\n\n";

    // Setup core components
    TrainDatabase& db = TrainDatabase::getInstance();
    TrainService trainService(db);

    PaymentFactory paymentFactory;
    PaymentService paymentService(paymentFactory);

    auto fareStrategy = std::make_unique<SimpleFareStrategy>();
    BookingService bookingService(trainService, paymentService, std::move(fareStrategy));

    // Seed initial trains
    seedTrains(trainService);

    // Create a user interactively
    std::string userName;
    std::string userEmail;
    std::cout << "Enter your name  : ";
    std::getline(std::cin, userName);
    if (userName.empty()) {
        std::getline(std::cin, userName); // handle possible leftover newline
    }
    std::cout << "Enter your email : ";
    std::getline(std::cin, userEmail);

    auto user = std::make_shared<User>(1, userName, userEmail);

    bool running = true;
    while (running) {
        std::cout << "\n=== Main Menu ===\n";
        std::cout << "1. Search & Book Ticket\n";
        std::cout << "2. Exit\n";
        std::cout << "Choose an option: ";

        int choice = 0;
        if (!(std::cin >> choice)) {
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::cout << "Invalid input. Please enter a number.\n";
            continue;
        }
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

        if (choice == 1) {
            std::string source;
            std::string destination;

            std::cout << "\nEnter source station      : ";
            std::getline(std::cin, source);
            std::cout << "Enter destination station : ";
            std::getline(std::cin, destination);

            std::vector<std::shared_ptr<Train>> trains =
                trainService.searchTrains(source, destination);

            if (trains.empty()) {
                std::cout << "No trains found for this route.\n";
                continue;
            }

            std::cout << "\nAvailable trains:\n";
            for (const auto& train : trains) {
                std::cout << "  ID: " << train->getId()
                          << ", Name: " << train->getName()
                          << ", Departure: " << train->getDepartureTime()
                          << ", Arrival: " << train->getArrivalTime()
                          << ", Fare/Seat: " << train->getFarePerSeat()
                          << ", Available Seats: " << train->getAvailableSeats()
                          << "\n";
            }

            int selectedTrainId;
            std::cout << "\nEnter Train ID to book: ";
            if (!(std::cin >> selectedTrainId)) {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                std::cout << "Invalid Train ID.\n";
                continue;
            }

            int seatsToBook;
            std::cout << "Enter number of seats   : ";
            if (!(std::cin >> seatsToBook) || seatsToBook <= 0) {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                std::cout << "Invalid seat count.\n";
                continue;
            }
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            std::string journeyDate;
            std::cout << "Enter journey date (YYYY-MM-DD): ";
            std::getline(std::cin, journeyDate);

            std::string paymentType;
            std::cout << "Select payment method [UPI/CARD/NETBANKING]: ";
            std::getline(std::cin, paymentType);

            auto ticket = bookingService.bookTicket(
                user, selectedTrainId, seatsToBook, journeyDate, paymentType);

            if (!ticket) {
                std::cout << "Booking failed. Please try again.\n";
                continue;
            }

            std::cout << "\nBooking successful. Ticket details:\n";
            ticket->print();

            char cancelChoice;
            std::cout << "\nDo you want to cancel this ticket? (y/n): ";
            std::cin >> cancelChoice;
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            if (cancelChoice == 'y' || cancelChoice == 'Y') {
                bool cancelled = bookingService.cancelTicket(ticket);
                if (cancelled) {
                    std::cout << "Ticket cancelled successfully.\n";
                } else {
                    std::cout << "Ticket cancellation failed.\n";
                }
                std::cout << "\nTicket details after cancellation:\n";
                ticket->print();
            }
        } else if (choice == 2) {
            running = false;
        } else {
            std::cout << "Invalid choice. Please select again.\n";
        }
    }

    std::cout << "\n=== Thank you for using IRCTC Demo ===\n";
    return 0;
}