//+------------------------------------------------------------------+
//|                                                       Symbol.mqh |
//|                                 Copyright 2016, Vasiliy Sokolov. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, Vasiliy Sokolov."
#property link      "http://www.mql5.com"
#include <Object.mqh>
#include "MarketBook.mqh"
#include "Series.mqh"
#include "SessionInfo.mqh"

//+------------------------------------------------------------------+
//| defines                                                          |
//+------------------------------------------------------------------+
class CSymbol : public CObject
{
private:
   string   m_symbol;               // Символ инструмента
   ENUM_TIMEFRAMES m_period;        // Таймфрейм инструмента
   
public:
            CSymbol(void);
            CSymbol(string symbol, ENUM_TIMEFRAMES period);
   // Based series
   CTime    Time;
   COpen    Open;
   CHigh    High;
   CLow     Low;
   CClose   Close;
   CVolume  Volume;
   CMarketBook    MarketBook;
   CSessionInfo   SessionInfo;
   // Based foo
   bool     InitSeries(string symbol,ENUM_TIMEFRAMES period);
   bool     Available(void);
   string   Name(void);
   bool     Name(string symbol);
   ENUM_TIMEFRAMES Period(void);
   bool     Period(ENUM_TIMEFRAMES period);
   // SymbolInfoInteger
   bool     SelectInMarketWatch(void);
   bool     SpreadFloat(void);
   int      Digits(void);
   int      Spread(void);
   int      StopLevel(void);
   int      FreezeLevel(void);
   int      FlagsExpirationOrders(void);
   int      FlagsExecutionOrders(void);
   int      FlagsAllowedOrders(void);
   int      IndexByTime(datetime time);
   int      BarsTotal(void);
   ENUM_SYMBOL_CALC_MODE CalcContractType(void);
   ENUM_SYMBOL_TRADE_MODE ExecuteOrderType(void);
   ENUM_SYMBOL_TRADE_EXECUTION ExecuteDealsType(void);
   ENUM_SYMBOL_SWAP_MODE CalcSwapMode(void);
   ENUM_DAY_OF_WEEK DayOfSwap3x(void);
   ENUM_SYMBOL_OPTION_MODE OptionType(void);
   ENUM_SYMBOL_OPTION_RIGHT OptionRight(void);
   datetime TimeOfLastQuote(void);
   datetime StartDate(void);
   datetime ExpirationDate(void);
   // SymbolInfoDouble
   double   Ask(void);
   double   Bid(void);
   double   Last(void);
   double   StepToPrice(int price_step);
   double   PriceStep(void);
   double   OptionStrike(void);
   double   TickValue(void);
   double   ContractSize(void);
   double   VolumeContractMin(void);
   double   VolumeContractMax(void);
   double   VolumeContractStep(void);
   double   VolumeContractLimit(void);
   double   SwapLong(void);
   double   SwapShort();
   double   MarginInit(void);
   double   MarginMaintenance(void);
   double   MarginHedged(void);
   // SymbolInfoString
   string   NameBasisSymbol(void);
   string   NameBasisCurrency(void);
   string   NameCurrencyProfit(void);
   string   NameCurrencyMargin(void);
   string   NameBank(void);
   string   Description(void);
   string   NameISIN(void);
   string   SymbolPath(void);
};
//+------------------------------------------------------------------+
//| Устанавливает серии OHLCV для текущего инструмента и таймфрейма  |
//+------------------------------------------------------------------+
CSymbol::CSymbol(void)
{
   m_symbol = ::Symbol();
   m_period = ::Period();
   InitSeries(Symbol(), ::Period());
}
//+------------------------------------------------------------------+
//| Возвращает общее количество баров данной инструмента по текущему |
//| таймфрейму                                                       |
//+------------------------------------------------------------------+
int CSymbol::BarsTotal(void)
{
   int bars = Bars(this.Name(), this.Period());
   return bars;
}
//+------------------------------------------------------------------+
//| Возвращает индекс бара, соответствующий указаному времени        |
//+------------------------------------------------------------------+
int CSymbol::IndexByTime(datetime time)
{
   int bars = Bars(this.Name(), this.Period(), time, TimeCurrent());
   return bars-1;
}
//+------------------------------------------------------------------+
//| Устанавливает серии OHLCV для указанного инструмента и таймфрейма|
//+------------------------------------------------------------------+
CSymbol::CSymbol(string symbol, ENUM_TIMEFRAMES period)
{
   m_symbol = symbol;
   m_period = period;
   InitSeries(symbol, period);
}
//+------------------------------------------------------------------+
//| Возвращает символ инструмента                                    |
//+------------------------------------------------------------------+
string CSymbol::Name(void)
{
   return m_symbol;
}
//+------------------------------------------------------------------+
//| Устанавливает символ инструмента                                 |
//+------------------------------------------------------------------+
bool CSymbol::Name(string symbol)
{
   m_symbol = symbol;
   InitSeries(m_symbol, m_period);
   return Available();
}
//+------------------------------------------------------------------+
//| Возвращает период инструмента                                    |
//+------------------------------------------------------------------+
ENUM_TIMEFRAMES CSymbol::Period(void)
{
   return m_period;
}
//+------------------------------------------------------------------+
//| Устанавливает период инструмента                                 |
//+------------------------------------------------------------------+
bool CSymbol::Period(ENUM_TIMEFRAMES period)
{
   m_period = period;
   InitSeries(m_symbol, m_period);
   return Available();
}
//+------------------------------------------------------------------+
//| Устанавливает серии OHLCV для текущего инструмента и таймфрейма. |
//| Возвращает истину, если инструмент доступен и ложь в противном   |
//| случае                                                           |
//+------------------------------------------------------------------+
bool CSymbol::InitSeries(string symbol,ENUM_TIMEFRAMES period)
{
   m_symbol = symbol;
   Time.Symbol(symbol);
   Time.Timeframe(period);
   Open.Symbol(symbol);
   Open.Timeframe(period);
   High.Symbol(symbol);
   High.Timeframe(period);
   Low.Symbol(symbol);
   Low.Timeframe(period);
   Close.Symbol(symbol);
   Close.Timeframe(period);
   Volume.Symbol(symbol);
   Volume.Timeframe(period);
   SessionInfo.Symbol(symbol);
   return Time.Total() > 0;
}
//+------------------------------------------------------------------+
//| Возвращает истину, если инструмент доступен для работы и ложь в  |
//| противном случае                                                 |
//+------------------------------------------------------------------+
bool CSymbol::Available(void)
{
   return Bars(m_symbol, m_period) > 0;
}
//+------------------------------------------------------------------+
//| Признак того, что данный инструмент присутствует в терминале     |
//+------------------------------------------------------------------+
bool CSymbol::SelectInMarketWatch(void)
{
   return (bool)SymbolInfoInteger(m_symbol, SYMBOL_SELECT);
}
//+------------------------------------------------------------------+
//| Признак плавающего спреда                                        |
//+------------------------------------------------------------------+
bool CSymbol::SpreadFloat(void)
{
   return (bool)SymbolInfoInteger(m_symbol, SYMBOL_SPREAD_FLOAT);
}
//+------------------------------------------------------------------+
//| Размер спреда в пунктах                                          |
//+------------------------------------------------------------------+
int CSymbol::Spread(void)
{
   return (int)SymbolInfoInteger(m_symbol, SYMBOL_SPREAD);
}
//+------------------------------------------------------------------+
//| Минимальный отступ в пунктах от текущей цены закрытия            |
//| для установки Stop ордеров                                       |
//+------------------------------------------------------------------+
int CSymbol::StopLevel(void)
{
   return (int)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_STOPS_LEVEL);
}
//+------------------------------------------------------------------+
//| Дистанция заморозки торговых операций (в пунктах)                |
//+------------------------------------------------------------------+
int CSymbol::FreezeLevel(void)
{
   return (int)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_FREEZE_LEVEL);
}
//+------------------------------------------------------------------+
//| Флаги разрешенных режимов истечения ордера                       |
//+------------------------------------------------------------------+
int CSymbol::FlagsExpirationOrders(void)
{
   return (int)SymbolInfoInteger(m_symbol, SYMBOL_EXPIRATION_MODE);
}
//+------------------------------------------------------------------+
//| Флаги разрешенных режимов исполнения ордера                      |
//+------------------------------------------------------------------+
int CSymbol::FlagsExecutionOrders(void)
{
   return (int)SymbolInfoInteger(m_symbol, SYMBOL_FILLING_MODE);
}
//+------------------------------------------------------------------+
//| Флаги разрешенных типов ордеров                                  |
//+------------------------------------------------------------------+
int CSymbol::FlagsAllowedOrders(void)
{
   return (int)SymbolInfoInteger(m_symbol, SYMBOL_ORDER_MODE);
}
//+------------------------------------------------------------------+
//| Признак того, что символ выбран в Market Watch                   |
//+------------------------------------------------------------------+
int CSymbol::Digits(void)
{
   int digits=(int)SymbolInfoInteger(m_symbol, SYMBOL_DIGITS);
   return digits;
}
//+------------------------------------------------------------------+
//| Способ вычисления стоимости контракта                            |
//+------------------------------------------------------------------+
ENUM_SYMBOL_CALC_MODE CSymbol::CalcContractType(void)
{
   return (ENUM_SYMBOL_CALC_MODE)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_CALC_MODE);
}
//+------------------------------------------------------------------+
//| Тип исполнения ордеров                                           |
//+------------------------------------------------------------------+
ENUM_SYMBOL_TRADE_MODE CSymbol::ExecuteOrderType(void)
{
   return (ENUM_SYMBOL_TRADE_MODE)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_MODE);
}
//+------------------------------------------------------------------+
//| Тип исполнения сделок                                            |
//+------------------------------------------------------------------+
ENUM_SYMBOL_TRADE_EXECUTION CSymbol::ExecuteDealsType(void)
{
   return (ENUM_SYMBOL_TRADE_EXECUTION)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_EXEMODE);
}
//+------------------------------------------------------------------+
//| Модель расчета свопа                                             |
//+------------------------------------------------------------------+
ENUM_SYMBOL_SWAP_MODE CSymbol::CalcSwapMode(void)
{
   return (ENUM_SYMBOL_SWAP_MODE)SymbolInfoInteger(m_symbol, SYMBOL_SWAP_MODE);
}
//+------------------------------------------------------------------+
//| День недели для начисления тройного свопа                        |
//+------------------------------------------------------------------+
ENUM_DAY_OF_WEEK CSymbol::DayOfSwap3x(void)
{
   return (ENUM_DAY_OF_WEEK)SymbolInfoInteger(m_symbol, SYMBOL_SWAP_ROLLOVER3DAYS);
}
//+------------------------------------------------------------------+
//| Тип опциона                                                      |
//+------------------------------------------------------------------+
ENUM_SYMBOL_OPTION_MODE CSymbol::OptionType(void)
{
   return (ENUM_SYMBOL_OPTION_MODE)SymbolInfoInteger(m_symbol, SYMBOL_OPTION_MODE);
}
//+------------------------------------------------------------------+
//| Право опциона (Call/Put)                                         |
//+------------------------------------------------------------------+
ENUM_SYMBOL_OPTION_RIGHT CSymbol::OptionRight(void)
{
   return (ENUM_SYMBOL_OPTION_RIGHT)SymbolInfoInteger(m_symbol, SYMBOL_OPTION_RIGHT);
}
//+------------------------------------------------------------------+
//| Время последней котировки                                        |
//+------------------------------------------------------------------+
datetime CSymbol::TimeOfLastQuote(void)
{
   return (datetime)SymbolInfoInteger(m_symbol, SYMBOL_TIME);
}
//+------------------------------------------------------------------+
//| Дата начала торгов по инструменту                                |
//+------------------------------------------------------------------+
datetime CSymbol::StartDate(void)
{
   return (datetime)SymbolInfoInteger(m_symbol, SYMBOL_START_TIME);
}
//+------------------------------------------------------------------+
//| Дата окончания торгов по инструменту                             |
//+------------------------------------------------------------------+
datetime CSymbol::ExpirationDate(void)
{
   return (datetime)SymbolInfoInteger(m_symbol, SYMBOL_EXPIRATION_TIME);
}
//+------------------------------------------------------------------+
//| Возвращает цену Ask.                                             |
//+------------------------------------------------------------------+
double CSymbol::Ask(void)
  {
   double ask = SymbolInfoDouble(m_symbol, SYMBOL_ASK);
   int digits = (int)SymbolInfoInteger(m_symbol, SYMBOL_DIGITS);
   ask=NormalizeDouble(ask,digits);
   return ask;
  }
//+------------------------------------------------------------------+
//| Возвращает цену Bid.                                             |
//+------------------------------------------------------------------+
double CSymbol::Bid(void)
  {
   double bid = SymbolInfoDouble(m_symbol, SYMBOL_BID);
   int digits = (int)SymbolInfoInteger(m_symbol, SYMBOL_DIGITS);
   bid=NormalizeDouble(bid,digits);
   return bid;
  }
//+------------------------------------------------------------------+
//| Возвращает цену Last.                                            |
//+------------------------------------------------------------------+
double CSymbol::Last(void)
  {
   double last= SymbolInfoDouble(m_symbol,SYMBOL_LAST);
   int digits =(int)SymbolInfoInteger(m_symbol,SYMBOL_DIGITS);
   last=NormalizeDouble(last,digits);
   return last;
  }
//+------------------------------------------------------------------+
//| Возвращает прайстепы в виде цены. Например переданное значение   |
//| 3 на EURUSD пятизнаке будет сконвертированно в 0.00003           |
//+------------------------------------------------------------------+
double CSymbol::StepToPrice(int price_step)
{
   double price = SymbolInfoDouble(m_symbol, SYMBOL_POINT)*(double)price_step;
   return price;
}
//+------------------------------------------------------------------+
//| Возвращает минимальное изменение цены инструмента, например для  |
//| EURUSD пятизнаке будет возвращено 0.00001                        |
//+------------------------------------------------------------------+
double CSymbol::PriceStep(void)
{
   double price = SymbolInfoDouble(m_symbol, SYMBOL_POINT);
   return price;
}
//+------------------------------------------------------------------+
//| Возвращает цену исполнения опциона                               |
//+------------------------------------------------------------------+
double CSymbol::OptionStrike(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_OPTION_STRIKE);
}
//+------------------------------------------------------------------+
//| Возвращает стоимость одного тика выраженную в валюте дипозита    |
//+------------------------------------------------------------------+
double CSymbol::TickValue(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_TRADE_TICK_VALUE);
}
//+------------------------------------------------------------------+
//| Размер одного контракта в базовых еденицах контракта             |
//+------------------------------------------------------------------+
double CSymbol::ContractSize(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_TRADE_CONTRACT_SIZE);
}
//+------------------------------------------------------------------+
//| Минимальный объем для заключения сделки, выраженный в контрактах |
//+------------------------------------------------------------------+
double CSymbol::VolumeContractMin(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_MIN);
}
//+-------------------------------------------------------------------+
//| Максимальный объем для заключения сделки, выраженный в контрактах |
//+-------------------------------------------------------------------+
double CSymbol::VolumeContractMax(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_MAX);
}
//+-------------------------------------------------------------------+
//| Максимально допустимый для данного символа совокупный объем       |
//| открытой позиции                                                  |
//+-------------------------------------------------------------------+
double CSymbol::VolumeContractLimit(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_LIMIT);
}
//+-------------------------------------------------------------------+
//| Минимальный шаг изменения объема для заключения сделки            |
//+-------------------------------------------------------------------+
double CSymbol::VolumeContractStep(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_STEP);
}
//+-------------------------------------------------------------------+
//| Значение свопа зачисляемого при удержании длиной позиции объемом  |
//| в один контракт                                                   |
//+-------------------------------------------------------------------+
double CSymbol::SwapLong(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_SWAP_LONG);
}
//+-------------------------------------------------------------------+
//| Значение свопа зачисляемого при удержании короткой позиции объемом|
//| в один контракт                                                   |
//+-------------------------------------------------------------------+
double CSymbol::SwapShort(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_SWAP_SHORT);
}
//+-------------------------------------------------------------------+
//| Маржа необходимая для открытия позиции размеров в один лот        |
//+-------------------------------------------------------------------+
double CSymbol::MarginInit(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_MARGIN_INITIAL);
}
//+-------------------------------------------------------------------+
//| Маржа необходимая для поддержания одного лота открытой позиции    |
//+-------------------------------------------------------------------+
double CSymbol::MarginMaintenance(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_MARGIN_MAINTENANCE);
}
//+-------------------------------------------------------------------+
//| Маржа необходимая для удержания одного лота перекрытой позиции    |
//+-------------------------------------------------------------------+
double CSymbol::MarginHedged(void)
{
   return SymbolInfoDouble(m_symbol, SYMBOL_MARGIN_HEDGED);
}
//+-------------------------------------------------------------------+
//| Имя базового актива для производного инструмента                  |
//+-------------------------------------------------------------------+
string CSymbol::NameBasisSymbol(void)
{
   return SymbolInfoString(m_symbol, SYMBOL_BASIS);
}
//+-------------------------------------------------------------------+
//| Базовая валюта инструмента                                        |
//+-------------------------------------------------------------------+
string CSymbol::NameBasisCurrency(void)
{
   return SymbolInfoString(m_symbol, SYMBOL_CURRENCY_BASE);
}
//+-------------------------------------------------------------------+
//| Валюта прибыли                                                    |
//+-------------------------------------------------------------------+
string CSymbol::NameCurrencyProfit(void)
{
   return SymbolInfoString(m_symbol, SYMBOL_CURRENCY_PROFIT);
}
//+-------------------------------------------------------------------+
//|  Валюта в которой вычисляется залоговые средства                  |
//+-------------------------------------------------------------------+
string CSymbol::NameCurrencyMargin(void)
{
   return SymbolInfoString(m_symbol, SYMBOL_CURRENCY_MARGIN);
}
//+-------------------------------------------------------------------+
//| Источник текущей котировки                                        |
//+-------------------------------------------------------------------+
string CSymbol::NameBank(void)
{
   return SymbolInfoString(m_symbol, SYMBOL_BANK);
}
//+-------------------------------------------------------------------+
//| Строковое описание символа                                        |
//+-------------------------------------------------------------------+
string CSymbol::Description(void)
{
   return SymbolInfoString(m_symbol, SYMBOL_DESCRIPTION);
}
//+-------------------------------------------------------------------+
//| Имя торгового символа в системе международных                     |
//| идентификационных кодов ценных бумаг — ISIN                       |
//+-------------------------------------------------------------------+
string CSymbol::NameISIN(void)
{
   return SymbolInfoString(m_symbol, SYMBOL_ISIN);
}
//+-------------------------------------------------------------------+
//| Путь в дереве символов                                            |
//+-------------------------------------------------------------------+
string CSymbol::SymbolPath(void)
{
   return SymbolInfoString(m_symbol, SYMBOL_PATH);
}