use core::time::Duration;

use log::{error, info};
use tokio::time::sleep;

use crate::BoxError;
use crate::connectors::ExchangeDetails;
use crate::currency::{Symbol, SymbolPair};
use crate::frontend::FrontendManagerHandle;
use crate::managers::ExchangeManager;
use crate::ticker::Ticker;

pub struct Rustico {
    ticker: Ticker,
    exchange_managers: Vec<ExchangeManager>,
    frontend_connector: FrontendManagerHandle,
}

impl Rustico {
    // TODO: change constructor to take SymbolPairs and not Symbol
    pub fn new(
        exchanges: Vec<ExchangeDetails>,
        trading_pairs: Vec<SymbolPair>,
        tick_duration: Duration,
    ) -> Self {
        let exchange_managers = exchanges
            .iter()
            .map(|x| ExchangeManager::new(x, &trading_pairs))
            .collect();

        Rustico {
            ticker: Ticker::new(tick_duration),
            exchange_managers,
            frontend_connector: FrontendManagerHandle::new(),
        }
    }

    pub async fn start_loop(&mut self) -> Result<(), BoxError> {
        self.update_exchanges().await?;

        loop {
            info!("Current tick: {}", self.ticker.current_tick());

            if let Err(e) = self.update().await {
                error!("Error in main bot loop: {}", e);
            }
        }
    }

    async fn update_exchanges(&mut self) -> Result<(), BoxError> {
        for e in &mut self.exchange_managers {
            if let Err(err) = e.update_managers(self.ticker.current_tick()).await {
                error!("Error while updating managers: {}", err);
            }
        }

        Ok(())
    }

    async fn update(&mut self) -> Result<(), BoxError> {
        sleep(self.ticker.duration()).await;
        self.ticker.inc();

        self.update_exchanges().await?;

        Ok(())
    }
}