QTradeProgram/TradingCore/common_structures/TradingStructures.h

#ifndef TRADING_STRUCTURES_H
#define TRADING_STRUCTURES_H

#include <QString>
#include <QDateTime>
#include <QVariant>
#include <QMap>
#include <QList>
#include <QVector>

// Basic trading data types
namespace Trading {

// Market types
enum class MarketType {
    HK,     // Hong Kong
    US,     // United States
    CN,     // China
    SG,     // Singapore
    JP,     // Japan
    Unknown
};

// Order types
enum class OrderType {
    Market,
    Limit,
    Stop,
    StopLimit,
    Iceberg,
    TWAP,
    VWAP,
    Unknown
};

// Order status
enum class OrderStatus {
    Pending,
    Submitted,
    PartiallyFilled,
    Filled,
    Cancelled,
    Rejected,
    Expired,
    Unknown
};

// Order side
enum class OrderSide {
    Buy,
    Sell,
    Short,
    Cover,
    Unknown
};

// Basic stock information
struct StockInfo {
    QString symbol;
    QString name;
    MarketType market;
    QString currency;
    double pricePrecision = 0.01;
    int quantityPrecision = 1;
    double minTradeAmount = 0.0;
    double maxTradeAmount = 0.0;
    bool isTradable = true;
    
    StockInfo() = default;
    StockInfo(const QString& sym, const QString& nm, MarketType mkt)
        : symbol(sym), name(nm), market(mkt) {}
};

// Real-time quote data
struct QuoteData {
    QString symbol;
    QDateTime timestamp;
    double lastPrice = 0.0;
    double openPrice = 0.0;
    double highPrice = 0.0;
    double lowPrice = 0.0;
    double closePrice = 0.0;
    double volume = 0.0;
    double turnover = 0.0;
    double bidPrice = 0.0;
    double askPrice = 0.0;
    qint64 bidVolume = 0;
    qint64 askVolume = 0;
    double change = 0.0;
    double changePercent = 0.0;
    
    bool isValid() const {
        return !symbol.isEmpty() && timestamp.isValid() && lastPrice > 0;
    }
};

// Order book level
struct OrderBookLevel {
    double price = 0.0;
    qint64 volume = 0;
    int orderCount = 0;
    
    OrderBookLevel() = default;
    OrderBookLevel(double p, qint64 v, int count = 1)
        : price(p), volume(v), orderCount(count) {}
};

// Complete order book
struct OrderBook {
    QString symbol;
    QDateTime timestamp;
    QVector<OrderBookLevel> bids;  // Buy side, sorted descending by price
    QVector<OrderBookLevel> asks;  // Sell side, sorted ascending by price
    
    bool isValid() const {
        return !symbol.isEmpty() && timestamp.isValid();
    }
    
    double getSpread() const {
        if (bids.isEmpty() || asks.isEmpty()) return 0.0;
        return asks.first().price - bids.first().price;
    }
    
    double getMidPrice() const {
        if (bids.isEmpty() || asks.isEmpty()) return 0.0;
        return (bids.first().price + asks.first().price) / 2.0;
    }
};

// Trading order
struct Order {
    QString orderId;
    QString symbol;
    OrderType type = OrderType::Limit;
    OrderSide side = OrderSide::Buy;
    OrderStatus status = OrderStatus::Pending;
    double price = 0.0;
    qint64 quantity = 0;
    qint64 filledQuantity = 0;
    double filledAmount = 0.0;
    QDateTime createTime;
    QDateTime updateTime;
    QString accountId;
    QString strategyId;
    QVariant customData;
    
    bool isValid() const {
        return !orderId.isEmpty() && !symbol.isEmpty() && quantity > 0;
    }
    
    double getAveragePrice() const {
        return filledQuantity > 0 ? filledAmount / filledQuantity : 0.0;
    }
    
    qint64 getRemainingQuantity() const {
        return quantity - filledQuantity;
    }
};

// Trade execution
struct Trade {
    QString tradeId;
    QString orderId;
    QString symbol;
    OrderSide side = OrderSide::Buy;
    double price = 0.0;
    qint64 quantity = 0;
    double amount = 0.0;
    QDateTime tradeTime;
    QString exchangeId;
    
    bool isValid() const {
        return !tradeId.isEmpty() && !orderId.isEmpty() && quantity > 0 && price > 0;
    }
};

// Position information
struct Position {
    QString symbol;
    QString accountId;
    qint64 quantity = 0;
    qint64 availableQuantity = 0;
    double averagePrice = 0.0;
    double marketValue = 0.0;
    double unrealizedPnl = 0.0;
    double realizedPnl = 0.0;
    QDateTime updateTime;
    
    bool isValid() const {
        return !symbol.isEmpty() && !accountId.isEmpty();
    }
};

// Account information
struct AccountInfo {
    QString accountId;
    QString accountName;
    double totalAssets = 0.0;
    double availableCash = 0.0;
    double frozenCash = 0.0;
    double margin = 0.0;
    double totalPnl = 0.0;
    double todayPnl = 0.0;
    QDateTime updateTime;
    
    bool isValid() const {
        return !accountId.isEmpty();
    }
};

// System configuration
struct SystemConfig {
    // Trading parameters
    double defaultOrderSize = 1000;
    double maxOrderSize = 10000;
    double minOrderSize = 100;
    int orderTimeoutSeconds = 30;
    
    // Risk parameters
    double maxPositionValue = 1000000.0;
    double maxDailyLoss = 50000.0;
    double maxSingleOrderValue = 100000.0;
    
    // Connection parameters
    int heartbeatIntervalMs = 5000;
    int reconnectTimeoutMs = 10000;
    int maxReconnectAttempts = 3;
    
    // Data parameters
    int dataBufferSize = 10000;
    int maxDataRatePerSecond = 1000;
    bool enableDataCompression = true;
    
    // Logging parameters
    bool enableDebugLog = false;
    int logRetentionDays = 30;
    QString logLevel = "INFO";
};

// Performance metrics
struct PerformanceMetrics {
    double totalReturn = 0.0;
    double dailyReturn = 0.0;
    double sharpeRatio = 0.0;
    double maxDrawdown = 0.0;
    double winRate = 0.0;
    double profitFactor = 0.0;
    int totalTrades = 0;
    int winningTrades = 0;
    int losingTrades = 0;
    double averageWin = 0.0;
    double averageLoss = 0.0;
    QDateTime periodStart;
    QDateTime periodEnd;
    
    void updateMetrics(bool isWin, double pnl) {
        totalTrades++;
        if (isWin) {
            winningTrades++;
            averageWin = (averageWin * (winningTrades - 1) + pnl) / winningTrades;
        } else {
            losingTrades++;
            averageLoss = (averageLoss * (losingTrades - 1) + pnl) / losingTrades;
        }
        winRate = static_cast<double>(winningTrades) / totalTrades;
        profitFactor = (averageWin * winningTrades) / (std::abs(averageLoss) * losingTrades);
    }
};

} // namespace Trading

#endif // TRADING_STRUCTURES_H