core/rustybot/src/managers.rs

use std::collections::{HashMap, VecDeque};

use crate::connectors::{Client, Connector};
use crate::currency::SymbolPair;
use crate::events::{Event, EventDispatcher, SignalKind};
use crate::models::{Order, Position, PriceTicker};
use crate::strategy::PositionStrategy;
use crate::ticker::Ticker;
use crate::BoxError;

pub struct EventManager {
    events: Vec<Event>,
}

#[derive(Clone, Debug)]
pub struct PriceManager {
    pair: SymbolPair,
    prices: Vec<PriceEntry>,
    client: Client,
}

impl PriceManager {
    pub fn new(pair: SymbolPair, client: Client) -> Self {
        PriceManager {
            pair,
            prices: Vec::new(),
            client,
        }
    }

    pub fn add_entry(&mut self, entry: PriceEntry) {
        self.prices.push(entry);
    }

    pub async fn update(&mut self, tick: u64) -> Result<PriceEntry, BoxError> {
        let current_prices = self.client.current_prices(&self.pair).await?.into();

        Ok(PriceEntry::new(
            tick,
            current_prices,
            self.pair.clone(),
            None,
            None,
        ))
    }

    // pub fn add_position(&mut self, position: Position) {
    //     let (new_position, events, signals) = {
    //         match &self.strategy {
    //             Some(strategy) => strategy.on_new_tick(&position, &self),
    //             None => (position, vec![], vec![]),
    //         }
    //     };
    //
    //     self.positions
    //         .entry(self.current_tick)
    //         .or_default()
    //         .push(new_position.clone());
    //
    //     // calling position state callbacks
    //     self.dispatcher
    //         .call_position_state_handlers(&new_position, &self);
    //
    //     // adding events and calling callbacks
    //     for e in events {
    //         self.add_event(e);
    //     }
    //
    //     // adding signals to current tick vector
    //     for s in signals {
    //         self.add_signal(s);
    //     }
    // }

    // fn add_event(&mut self, event: Event) {
    //     self.events.push(event);
    //
    //     self.dispatcher.call_event_handlers(&event, &self);
    // }
    //
    // fn add_signal(&mut self, signal: SignalKind) {
    //     self.signals.insert(self.current_tick(), signal);
    // }

    pub fn pair(&self) -> &SymbolPair {
        &self.pair
    }

    // pub fn position_previous_tick(&self, id: u64, tick: Option<u64>) -> Option<&Position> {
    //     let tick = match tick {
    //         Some(tick) => {
    //             if tick < 1 {
    //                 1
    //             } else {
    //                 tick
    //             }
    //         }
    //         None => self.current_tick() - 1,
    //     };
    //
    //     self.positions
    //         .get(&tick)
    //         .and_then(|x| x.iter().find(|x| x.position_id() == id))
    // }
}

#[derive(Clone, Debug)]
pub struct PriceEntry {
    tick: u64,
    pair: SymbolPair,
    price: PriceTicker,
    events: Option<Vec<Event>>,
    signals: Option<Vec<SignalKind>>,
}

impl PriceEntry {
    pub fn new(
        tick: u64,
        price: PriceTicker,
        pair: SymbolPair,
        events: Option<Vec<Event>>,
        signals: Option<Vec<SignalKind>>,
    ) -> Self {
        PriceEntry {
            tick,
            pair,
            price,
            events,
            signals,
        }
    }

    pub fn tick(&self) -> u64 {
        self.tick
    }
    pub fn pair(&self) -> &SymbolPair {
        &self.pair
    }
    pub fn price(&self) -> PriceTicker {
        self.price
    }
    pub fn events(&self) -> &Option<Vec<Event>> {
        &self.events
    }
    pub fn signals(&self) -> &Option<Vec<SignalKind>> {
        &self.signals
    }
}

pub struct PositionManager {
    queue: VecDeque<Position>,
    open_positions: Vec<Position>,
    client: Client,
    strategy: Option<Box<dyn PositionStrategy>>,
}

impl PositionManager {
    pub fn new(client: Client) -> Self {
        PositionManager {
            queue: VecDeque::new(),
            open_positions: Vec::new(),
            client,
            strategy: None,
        }
    }

    pub fn with_strategy(mut self, strategy: Box<dyn PositionStrategy>) -> Self {
        self.strategy = Some(strategy);
        self
    }

    pub fn update(&self) -> Option<Vec<Event>> {
        unimplemented!()
    }
}

pub struct OrderManager {
    queue: VecDeque<Order>,
    open_orders: Vec<Order>,
    client: Client,
}

impl OrderManager {
    pub fn new(client: Client) -> Self {
        OrderManager {
            queue: VecDeque::new(),
            open_orders: Vec::new(),
            client,
        }
    }

    pub fn update(&self) -> Option<Vec<Event>> {
        unimplemented!()
    }
}