shuttle-sdk 0.1.0

use reqwest::IntoUrl;
use shuttle_core::{PublicKey, SignedTransaction};
use client::InnerClient;
use error::{Error, Result};
use accounts::AccountsRequest;
use assets::AssetsRequest;
use effects::EffectsRequest;
use ledgers::LedgersRequest;
use offers::OffersRequest;
use operations::OperationsRequest;
use orderbook::OrderbookRequest;
use paths::PathsRequest;
use payments::PaymentsRequest;
use trade_aggregations::TradeAggregationsRequest;
use trades::TradesRequest;
use transactions::TransactionsRequest;
use submit_transaction::SubmitTransactionRequest;
use friendbot::FriendbotRequest;

/// Handle connection to the Horizon server.
#[derive(Debug, Clone)]
pub struct Server {
    inner: InnerClient,
}

impl Server {
    /// Create a new `Server`. Will return error if the connection is not secure.
    pub fn new<U: IntoUrl>(horizon_url: U) -> Result<Server> {
        let horizon_url = horizon_url.into_url()?;
        if horizon_url.scheme() == "http" {
            return Err(Error::UnsecureConnection);
        }
        Self::new_unsecure(horizon_url)
    }

    /// Create a new `Server`.
    pub fn new_unsecure<U: IntoUrl>(horizon_url: U) -> Result<Server> {
        let inner = InnerClient::new(horizon_url.into_url()?)?;
        Ok(Server { inner })
    }

    /// Create accounts request.
    pub fn accounts(&self) -> AccountsRequest {
        AccountsRequest::new(self.inner.clone())
    }

    /// Create assets request.
    pub fn assets(&self) -> AssetsRequest {
        AssetsRequest::new(self.inner.clone())
    }

    /// Create effects request.
    pub fn effects(&self) -> EffectsRequest {
        EffectsRequest::new(self.inner.clone())
    }

    /// Create ledgers request.
    pub fn ledgers(&self) -> LedgersRequest {
        LedgersRequest::new()
    }

    /// Create offers request.
    pub fn offers(&self) -> OffersRequest {
        unimplemented!()
    }

    /// Create operations request.
    pub fn operations(&self) -> OperationsRequest {
        unimplemented!()
    }

    /// Create orderbook request.
    pub fn orderbook(&self) -> OrderbookRequest {
        unimplemented!()
    }

    /// Create paths request.
    pub fn paths(&self) -> PathsRequest {
        unimplemented!()
    }

    /// Create payments request.
    pub fn payments(&self) -> PaymentsRequest {
        unimplemented!()
    }

    /// Create trade aggregation request.
    pub fn trade_aggregations(&self) -> TradeAggregationsRequest {
        unimplemented!()
    }

    /// Create trades request.
    pub fn trades(&self) -> TradesRequest {
        unimplemented!()
    }

    /// Create transactions request.
    pub fn transactions(&self) -> TransactionsRequest {
        unimplemented!()
    }

    /// Create friendbot request.
    pub fn friendbot(&self, account_id: &PublicKey) -> Result<FriendbotRequest> {
        FriendbotRequest::new(self.inner.clone(), &account_id)
    }

    /// Submit transaction to server.
    pub fn submit_transaction(&self, tx: &SignedTransaction) -> Result<SubmitTransactionRequest> {
        SubmitTransactionRequest::new(self.inner.clone(), &tx)
    }
}