#ifndef FRAMEWORK_KERNEL_MARKET_MQH
#define FRAMEWORK_KERNEL_MARKET_MQH

class kernel_market {
public:
	static double price_buy ( string symbol ) {
		MqlTick last_tick;
		SymbolInfoTick ( symbol, last_tick );
		return last_tick.ask;
	}

	static double price_sell ( string symbol ) {
		MqlTick last_tick;
		SymbolInfoTick ( symbol, last_tick );
		return last_tick.bid;
	}

	static double price_day_min ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_LASTLOW );
	}

	static double price_day_min ( ) {
		return price_day_min ( CURRENT_SYMBOL );
	}

	static double price_day_max ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_LASTHIGH );
	}

	static double price_day_max ( ) {
		return price_day_max ( CURRENT_SYMBOL );
	}

	static double tick_value ( string symbol ) {
		double res =0;
		for (int i = 0; i < 10; i++)
		{
		   MqlTick m_tick;
   	   if (SymbolInfoTick(symbol, m_tick))
   	   {
      		res = SymbolInfoDouble ( symbol, SYMBOL_TRADE_TICK_VALUE );
      		if(res != 0)
      	      break;
		   }
		   if (i == 9)
		   {
		      if (OrderCalcProfit(ORDER_TYPE_BUY, symbol,1,m_tick.bid,m_tick.bid+SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE), res) 
		          && res != 0
		         )
		         break;
		      Print(__FUNCTION__," Cant get symbol data! Attemp to calculate!");
		      res = CalcTickValue();
		      //OnDeinit(10);
		   }
		   Sleep(100);
		}      
		//if (res == 0)
		//   res = SymbolInfoDouble (symbol,SYMBOL_TRADE_TICK_VALUE_LOSS);
		//if(res == 0)
		//   Print(__FUNCTION__," Zero tick value detected!");
		return res;
		
	}

	static double tick_value () {
		return tick_value ( CURRENT_SYMBOL );
	}

	static double tick_size ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_TRADE_TICK_SIZE );
	}

	static double tick_size () {
		return tick_size ( CURRENT_SYMBOL );
	}

	static datetime tick_last_time ( string symbol ) {
		return (datetime)SymbolInfoInteger ( symbol, SYMBOL_TIME );
	}

	static datetime tick_last_time () {
		return tick_last_time ( CURRENT_SYMBOL );
	}

	static double lot_min ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_VOLUME_MIN );
	}

	static double lot_min () {
		return lot_min ( CURRENT_SYMBOL );
	}

	static double lot_size ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_TRADE_CONTRACT_SIZE );
	}

	static double lot_size () {
		return lot_size ( CURRENT_SYMBOL );
	}

	static double lot_step ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_VOLUME_STEP );
	}

	static double lot_step () {
		return lot_size ( CURRENT_SYMBOL );
	}

	static double lot_max ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_VOLUME_MAX );
	}

	static double lot_max () {
		return lot_max ( CURRENT_SYMBOL );
	}

	static enum_swap_type swap_type ( string symbol ) {
		return ( enum_swap_type ) SymbolInfoInteger ( symbol, SYMBOL_SWAP_MODE );
	}

	static enum_swap_type swap_type () {
		return swap_type ( CURRENT_SYMBOL );
	}

	static double swap_long ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_SWAP_LONG );
	}

	static double swap_long ( ) {
		return swap_long ( CURRENT_SYMBOL );
	}

	static double swap_short ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_SWAP_SHORT );
	}

	static double swap_short ( ) {
		return swap_short ( CURRENT_SYMBOL );
	}

	static enum_margin_calc_type margin_calc_type ( string symbol ) {
		return margin_calc_type_forex;
	}

	static enum_margin_calc_type margin_calc_type () {
		return margin_calc_type_forex;
	}

	static double margin_required ( string symbol ) {
		double result = -255;
		double request_result = OrderCalcMargin ( ORDER_TYPE_BUY,
								symbol,
								1.0,
								price_buy ( symbol ),
								result );

		if ( !request_result ) {
			Print ( StringFormat ( "%d", layer_error::get_last() ) );
		}

		return result;
	}

	static double margin_required ( ) {
		return 0.0;
	}

	static double margin_hedged ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_MARGIN_HEDGED );
	}

	static double margin_hedged (  ) {
		return SymbolInfoDouble ( CURRENT_SYMBOL, SYMBOL_MARGIN_HEDGED );
	}

	static double margin_maintenance ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_MARGIN_MAINTENANCE );
	}

	static double margin_maintenance () {
		return SymbolInfoDouble ( CURRENT_SYMBOL, SYMBOL_MARGIN_MAINTENANCE );
	}

	static double margin_init ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_MARGIN_INITIAL );
	}

	static double margin_init () {
		return SymbolInfoDouble ( CURRENT_SYMBOL, SYMBOL_MARGIN_INITIAL );
	}

	static double point ( string symbol ) {
		return SymbolInfoDouble ( symbol, SYMBOL_POINT );
	}

	static double point () {
		return point ( CURRENT_SYMBOL );
//      return SymbolInfoDouble ( CURRENT_SYMBOL, SYMBOL_POINT );
	}

	static datetime starting ( string symbol ) {
		return 0;
	}

	static datetime starting ( ) {
		return 0;
	}

	static datetime expiration ( string symbol ) {
		return 0;
	}

	static datetime expiration () {
		return 0;
	}

	static bool trade_allowed ( string symbol ) {
	   if ( SymbolInfoInteger( symbol, SYMBOL_TRADE_MODE) == SYMBOL_TRADE_MODE_FULL ) return true;
	         
		return false;
	}

	static bool trade_allowed () {
	   return trade_allowed( CURRENT_SYMBOL );
		return false;
	}

	static int stop_level ( string symbol ) {
		return (int)SymbolInfoInteger ( symbol, SYMBOL_TRADE_STOPS_LEVEL );
	}

	static double stop_level () {
		return stop_level ( CURRENT_SYMBOL );
	}

	static double freeze_level ( string symbol ) {
		return (double)SymbolInfoInteger ( symbol, SYMBOL_TRADE_FREEZE_LEVEL );
	}

	static double freeze_level () {
		return (double)freeze_level ( CURRENT_SYMBOL );
	}

	static int spread ( string symbol ) {
		return (int)SymbolInfoInteger ( symbol, SYMBOL_SPREAD );
	}

	static int spread () {
		return (int)spread ( CURRENT_SYMBOL );
	}

	static int digits ( string symbol ) {
		return (int)SymbolInfoInteger ( symbol, SYMBOL_DIGITS );
	}

	static int digits () {
		return digits ( CURRENT_SYMBOL );
	}

	static enum_profit_calc_type profit_calc_type ( string symbol ) {
		return ( enum_profit_calc_type ) SymbolInfoInteger ( symbol, SYMBOL_TRADE_CALC_MODE );
	}

	static enum_profit_calc_type profit_calc_type () {
		return profit_calc_type ( CURRENT_SYMBOL );
	}
	static double CalcTickValue()
	{
	   int count = kernel_order::count();
	   double   open_price,
	            price,
	            lots,
	            profit;
	   for (int i = 0; i < count; i++)
	   {
	      if (kernel_order::select_by_index( i ) && kernel_order::symbol() == CURRENT_SYMBOL)
	      {
	         open_price = kernel_order::open_price();
	         price = (kernel_order::type()== order_operation_buy || kernel_order::type() == order_operation_buy_stop)? 
	                                 kernel_market::price_sell(CURRENT_SYMBOL):
	                                 kernel_market::price_buy(CURRENT_SYMBOL);
	         lots = kernel_order::lots();
	         profit = kernel_order::get_profit(true);
	         if(profit !=  0 && lots != 0 && open_price != price)
	            return MathAbs(open_price - price)/profit/lots;
	      }
	   }
	Print(__FUNCTION__," ",__LINE__," Can't calculate TickValue!");
	return 1;
	}
};

#endif