3 files changed, 149 insertions, 0 deletions
diff --git a/rust_backend/src/market/mod.rs b/rust_backend/src/market/mod.rs
new file mode 100644
index 0000000..16d1f37
--- /dev/null
+++ b/rust_backend/src/market/mod.rs
@@ -0,0 +1,3 @@
+mod order;
+
+pub use order::{Order, Orders};
+\ No newline at end of file
diff --git a/rust_backend/src/market/order.rs b/rust_backend/src/market/order.rs
new file mode 100644
index 0000000..6dbbcf6
--- /dev/null
+++ b/rust_backend/src/market/order.rs
@@ -0,0 +1,83 @@
+use std::error::Error;
+use std::collections::HashMap;
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+use crate::eve_service::EveService;
+
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct Order {
+    duration: u64,
+    is_buy_order: bool,
+    issued: DateTime<Utc>,
+    location_id: u64,
+    min_volume: u64,
+    order_id: u64,
+    price: f64,
+    range: String,
+    system_id: u64,
+    type_id: u64,
+    volume_remain: u64,
+    volume_total: u64
+}
+
+const REGIONS: [u64; 1] = [10000033];
+
+#[derive(Clone, Serialize)]
+pub struct Orders {
+    region_orders: HashMap<u64, Vec<Order>>,
+    expiry_times: HashMap<u64, DateTime<Utc>>, // region_id to expiration time
+}
+
+
+impl Orders {
+    pub fn new() -> Self {
+        Orders {
+            region_orders: HashMap::new(),
+            expiry_times: HashMap::new(),
+        }
+    }
+
+    pub fn insert(&mut self, region: u64, orders: Vec<Order>, expiry: DateTime<Utc>) {
+        self.region_orders.insert(region, orders);
+        self.expiry_times.insert(region, expiry);
+    }
+
+    pub fn expired_regions(&self) -> Vec<u64> {
+        let current_time = Utc::now();
+
+        println!("expiry: {:?}, time now: {:?}", &self.expiry_times, &current_time);
+
+        let mut expired: Vec<u64> = self.expiry_times.iter()
+            .filter(|&(_region_id, &expiry_time)| expiry_time < current_time)
+            .map(|(&region_id, _)| region_id)
+            .collect();
+
+        for &region in REGIONS.iter() {
+            if !self.expiry_times.contains_key(&region) {
+                expired.push(region);
+            }
+        }
+    
+
+        expired
+
+    }
+
+    pub fn update(&mut self, updated_orders: Orders) {
+        for (key, value) in updated_orders.region_orders {
+            self.region_orders.insert(key, value);
+
+            if let Some(expiry_time) = updated_orders.expiry_times.get(&key) {
+                self.expiry_times.insert(key, *expiry_time);
+            }
+        }
+    }
+
+
+    pub fn orders(&self) -> Vec<Order> {
+        self.region_orders.values().flat_map(|orders| orders.clone()).collect()
+    }
+}
+\ No newline at end of file
diff --git a/rust_backend/src/market/trade.rs b/rust_backend/src/market/trade.rs
new file mode 100644
index 0000000..362acbf
--- /dev/null
+++ b/rust_backend/src/market/trade.rs
@@ -0,0 +1,63 @@
+use crate::order::Order;
+
+pub struct Trade<'a> {
+    from: &'a Order,
+    to: &'a Order,
+    quantity: usize,
+    gross_profit: f64,
+}
+
+const TAX_RATE: f64 = 0.08
+
+impl<'a> Trade<'a> {
+    pub fn new(from: &'a Order, to: &'a Order, quantity: usize) -> Self {
+        Self { from, to, quantity }
+    }
+
+    pub fn create_trades(sell_orders: &'a [Order], buy_orders: &'a [Order]) -> Vec<Trade<'a>> {
+        let mut trades: Vec<Trade<'a>> = Vec::new();
+        let mut grouped_orders: HashMap<i32, (Vec<&'a Order>, Vec<&'a Order>)> = HashMap::new();
+
+        // Grouping sell orders
+        for order in sell_orders {
+            grouped_orders.entry(order.type_id)
+                .or_insert((Vec::new(), Vec::new()))
+                .0
+                .push(order);
+        }
+
+        // Grouping buy orders
+        for order in buy_orders {
+            grouped_orders.entry(order.type_id)
+                .or_insert((Vec::new(), Vec::new()))
+                .1
+                .push(order);
+        }
+
+        // Iterating over each type_id's sell and buy orders to create trades
+        for (_type_id, (sells, buys)) in grouped_orders {
+            for &sell_order in sells {
+                for &buy_order in buys {
+                    let quantity = std::cmp::min(sell_order.volume_remain, buy_order.volume_remain);
+                    let gross_profit = quantity as f64 * (buy_order.price * (1-TAX_RATE) - sell_order.price);
+
+                    if gross_profit <= 0.0 {
+                        continue;
+                    }
+
+                    let trade = Trade::new(
+                        sell_order,  
+                        buy_order,
+                        quantity,
+                        gross_profit,
+                    );
+
+                    trades.push(trade);
+                }
+            }
+        }
+
+        trades
+    }
+
+}