BitCoinTransaction

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <iomanip>

using namespace std;

enum class TransactionStatus { PENDING, COMPLETED, CANCELED, PAUSED };

class Transaction {
public:
    Transaction(const string &userId, double amount, int counter)
        : userId(userId), amount(amount), status(TransactionStatus::PENDING), timestamp(counter) {
        id = generateUniqueId();
    }

    string getId() const { return id; }
    string getUserId() const { return userId; }
    double getAmount() const { return amount; }
    TransactionStatus getStatus() const { return status; }
    void setStatus(TransactionStatus newStatus) { status = newStatus; }
    int getTimestamp() const { return timestamp; }

    void display() const {
        if (status == TransactionStatus::CANCELED) return;
        cout << "Transaction{id='" << id << "', userId='" << userId 
             << "', amount=" << amount << ", timestamp=" 
             << timestamp << ", status='" << statusToString(status) << "'}\n";
    }

private:
    string id;
    string userId;
    double amount;
    TransactionStatus status;
    int timestamp;

    static string generateUniqueId() {
        static int counter = 0;
        return "tx" + to_string(++counter);
    }

    static string statusToString(TransactionStatus status) {
        switch (status) {
            case TransactionStatus::PENDING: return "PENDING";
            case TransactionStatus::COMPLETED: return "COMPLETED";
            case TransactionStatus::CANCELED: return "CANCELED";
            case TransactionStatus::PAUSED: return "PAUSED";
            default: return "UNKNOWN";
        }
    }
};

class TransactionService {
public:
    void addTransaction(const string &userId, double amount) {
        counter++;  // Increment the counter with each transaction
        transactions.push_back(Transaction(userId, amount, counter));
    }

    void displayTransactionHistory() {
        sortTransactions();
        for (const auto &transaction : transactions) {
            transaction.display();
        }
    }

    bool cancelTransaction(const string &transactionId) {
        for (auto &transaction : transactions) {
            if (transaction.getId() == transactionId && transaction.getStatus() != TransactionStatus::COMPLETED) {
                transaction.setStatus(TransactionStatus::CANCELED);
                return true;
            }
        }
        return false;
    }

    bool pauseTransaction(const string &transactionId) {
        for (auto &transaction : transactions) {
            if (transaction.getId() == transactionId && transaction.getStatus() == TransactionStatus::PENDING) {
                transaction.setStatus(TransactionStatus::PAUSED);
                return true;
            }
        }
        return false;
    }

    bool cancelAllUserTransactions(const string &userId) {
        bool anyCancelled = false;
        for (auto &transaction : transactions) {
            if (transaction.getUserId() == userId && transaction.getStatus() != TransactionStatus::COMPLETED) {
                transaction.setStatus(TransactionStatus::CANCELED);
                anyCancelled = true;
            }
        }
        return anyCancelled;
    }

private:
    vector<Transaction> transactions;
    int counter = 0;  // Counter to simulate incremental timestamps

    void sortTransactions() {
        sort(transactions.begin(), transactions.end(),
             [](const Transaction &a, const Transaction &b) {
                 return a.getTimestamp() > b.getTimestamp();
             });
    }
};

int main() {
    TransactionService transactionService;

    // Adding some transactions for demonstration
    transactionService.addTransaction("user1", 0.05);
    transactionService.addTransaction("user2", 0.02);
    transactionService.addTransaction("user1", 0.03);
    transactionService.addTransaction("user3", 0.07);

    // Display transaction history
    cout << "\nTransaction History:\n";
    transactionService.displayTransactionHistory();

    // Cancel a specific transaction (let's assume tx1 is the ID)
    cout << "\nCanceling transaction with ID tx1...\n";
    transactionService.cancelTransaction("tx1");

    // Display transaction history again
    cout << "\nUpdated Transaction History:\n";
    transactionService.displayTransactionHistory();

    // Pause a specific transaction (let's assume tx2 is the ID)
    cout << "\nPausing transaction with ID tx2...\n";
    transactionService.pauseTransaction("tx2");

    // Display transaction history again
    cout << "\nUpdated Transaction History:\n";
    transactionService.displayTransactionHistory();

    // Cancel all transactions for a user (user1)
    cout << "\nCanceling all transactions for user1...\n";
    transactionService.cancelAllUserTransactions("user1");

    // Final display of transaction history
    cout << "\nFinal Transaction History:\n";
    transactionService.displayTransactionHistory();

    return 0;
}