fix: various fixes and patches

Author: Swofty-Developments

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>net.swofty</groupId>
     <artifactId>stockmarkettester</artifactId>
-    <version>1.1.1</version>
+    <version>1.1.6</version>
 
     <properties>
         <maven.compiler.source>21</maven.compiler.source>

src/main/java/net/swofty/stockmarkettester/Portfolio.java

@@ -17,6 +17,7 @@ public class Portfolio {
     private final Map<String, List<Option>> options;
     private final Map<String, List<StopOrder>> stopOrders;
     private final Map<String, ShortOrder> shortPositions;
+    private final Map<String, Double> cachedValues;
     private double cash;
     private double marginAvailable;
     private static final double MARGIN_REQUIREMENT = 0.5; // 50% margin requirement
@@ -27,6 +28,7 @@ public Portfolio(double initialCash) {
         this.options = new ConcurrentHashMap<>();
         this.stopOrders = new ConcurrentHashMap<>();
         this.shortPositions = new ConcurrentHashMap<>();
+        this.cachedValues = new ConcurrentHashMap<>();
         this.cash = initialCash;
         this.marginAvailable = initialCash * 2; // 2x leverage
     }
@@ -159,16 +161,24 @@ public double getRealizedPnL(String ticker) {
     }
 
     public double getTotalValue(Map<String, MarketDataPoint> currentPrices) {
+        positions.forEach((k, v) -> {
+            if (currentPrices.containsKey(k)) {
+                cachedValues.put(k, currentPrices.get(k).close());
+            }
+        });
+
         double longValue = positions.entrySet().stream()
                 .mapToDouble(entry -> {
                     MarketDataPoint price = currentPrices.get(entry.getKey());
+                    if (price == null) return cachedValues.get(entry.getKey());
                     return entry.getValue().quantity() * price.close();
                 })
                 .sum();
 
         double shortValue = shortPositions.entrySet().stream()
                 .mapToDouble(entry -> {
                     MarketDataPoint price = currentPrices.get(entry.getKey());
+                    if (price == null) return cachedValues.get(entry.getKey());
                     return -entry.getValue().quantity() * price.close();
                 })
                 .sum();

src/main/java/net/swofty/stockmarkettester/data/HistoricalMarketService.java

@@ -19,7 +19,10 @@ public class HistoricalMarketService implements AutoCloseable {
     private final Map<String, HistoricalData> historicalCache;
     @Getter
     private final MarketDataProvider provider;
+
     private final ExecutorService requestExecutor;
+    private final ExecutorService fetchExecutor;
+
     private final int maxRetries;
     private volatile boolean isInitialized = false;
     private final Object initLock = new Object();
@@ -30,6 +33,7 @@ public HistoricalMarketService(MarketDataProvider provider, int maxRetries, Path
         this.provider = provider;
         this.historicalCache = new ConcurrentHashMap<>();
         this.requestExecutor = Executors.newSingleThreadExecutor();
+        this.fetchExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
         this.maxRetries = maxRetries;
         this.cacheDirectory = Optional.ofNullable(cacheDirectory);
 
@@ -166,28 +170,39 @@ public CompletableFuture<Map<String, List<MarketDataPoint>>> fetchHistoricalData
             LocalDateTime start,
             LocalDateTime end) {
 
-        return CompletableFuture.supplyAsync(() -> {
-            if (!isInitialized) {
-                throw new IllegalStateException("HistoricalMarketService not initialized");
-            }
-
-            Map<String, List<MarketDataPoint>> result = new ConcurrentHashMap<>();
+        if (!isInitialized) {
+            throw new IllegalStateException("HistoricalMarketService not initialized");
+        }
 
-            for (String ticker : tickers) {
-                HistoricalData cachedData = historicalCache.get(ticker);
-                if (cachedData == null && cacheDirectory.isPresent()) {
-                    // Try loading from file cache as fallback if caching is enabled
-                    cachedData = loadFromCache(ticker, start, end);
-                    if (cachedData == null) {
-                        throw new IllegalStateException("No cached data for ticker: " + ticker);
+        Map<String, List<MarketDataPoint>> result = new ConcurrentHashMap<>();
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+
+        for (String ticker : tickers) {
+            CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
+                try {
+                    HistoricalData cachedData = historicalCache.get(ticker);
+                    if (cachedData == null && cacheDirectory.isPresent()) {
+                        cachedData = loadFromCache(ticker, start, end);
+                        if (cachedData == null) {
+                            throw new IllegalStateException("No cached data for ticker: " + ticker);
+                        }
+                        historicalCache.put(ticker, cachedData);
                     }
-                    historicalCache.put(ticker, cachedData);
+                    if (cachedData != null) {
+                        result.put(ticker, cachedData.getDataPoints(start, end));
+                    } else {
+                        throw new IllegalStateException("No data available for ticker: " + ticker);
+                    }
+                } catch (Exception e) {
+                    throw new CompletionException(e);
                 }
-                result.put(ticker, cachedData.getDataPoints(start, end));
-            }
+            }, fetchExecutor);
 
-            return result;
-        });
+            futures.add(future);
+        }
+
+        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
+                .thenApply(v -> result);
     }
 
     public void clearCache() {
@@ -211,12 +226,17 @@ public void clearCache() {
     @Override
     public void close() {
         requestExecutor.shutdown();
+        fetchExecutor.shutdown();
         try {
             if (!requestExecutor.awaitTermination(30, TimeUnit.SECONDS)) {
                 requestExecutor.shutdownNow();
             }
+            if (!fetchExecutor.awaitTermination(30, TimeUnit.SECONDS)) {
+                fetchExecutor.shutdownNow();
+            }
         } catch (InterruptedException e) {
             requestExecutor.shutdownNow();
+            fetchExecutor.shutdownNow();
             Thread.currentThread().interrupt();
         }
     }