// File: NT8StrategyBase.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using NinjaTrader.Cbi;
using NinjaTrader.Data;
using NinjaTrader.Gui;
using NinjaTrader.Gui.Chart;
using NinjaTrader.Gui.Tools;
using NinjaTrader.NinjaScript;
using NinjaTrader.NinjaScript.Indicators;
using NinjaTrader.NinjaScript.Strategies;
using NT8.Adapters.NinjaTrader;
using NT8.Core.Common.Interfaces;
using NT8.Core.Common.Models;
using NT8.Core.Execution;
using NT8.Core.Logging;
using NT8.Core.Risk;
using NT8.Core.Sizing;
using SdkPosition = NT8.Core.Common.Models.Position;
using SdkOrderSide = NT8.Core.Common.Models.OrderSide;
using SdkOrderType = NT8.Core.Common.Models.OrderType;
using OmsOrderRequest = NT8.Core.OMS.OrderRequest;
using OmsOrderSide = NT8.Core.OMS.OrderSide;
using OmsOrderType = NT8.Core.OMS.OrderType;
using OmsOrderState = NT8.Core.OMS.OrderState;
using OmsOrderStatus = NT8.Core.OMS.OrderStatus;

namespace NinjaTrader.NinjaScript.Strategies
{
    /// <summary>
    /// Base class for strategies that integrate NT8 SDK components.
    /// </summary>
    public abstract class NT8StrategyBase : Strategy, INT8ExecutionBridge
    {
        private readonly object _lock = new object();

        protected IStrategy _sdkStrategy;
        protected IRiskManager _riskManager;
        protected IPositionSizer _positionSizer;
        protected NT8ExecutionAdapter _executionAdapter;
        protected ILogger _logger;

        protected StrategyConfig _strategyConfig;
        protected RiskConfig _riskConfig;
        protected SizingConfig _sizingConfig;

        private bool _sdkInitialized;
        private AccountInfo _lastAccountInfo;
        private SdkPosition _lastPosition;
        private MarketSession _currentSession;
        private int _ordersSubmittedToday;
        private DateTime _lastBarTime;
        private bool _killSwitchTriggered;
        private ExecutionCircuitBreaker _circuitBreaker;
        private System.IO.StreamWriter _fileLog;
        private readonly object _fileLock = new object();

        #region User-Configurable Properties

        [NinjaScriptProperty]
        [Display(Name = "Enable SDK", GroupName = "SDK", Order = 1)]
        public bool EnableSDK { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Daily Loss Limit", GroupName = "Risk", Order = 1)]
        public double DailyLossLimit { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Max Trade Risk", GroupName = "Risk", Order = 2)]
        public double MaxTradeRisk { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Max Positions", GroupName = "Risk", Order = 3)]
        public int MaxOpenPositions { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Risk Per Trade", GroupName = "Sizing", Order = 1)]
        public double RiskPerTrade { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Min Contracts", GroupName = "Sizing", Order = 2)]
        public int MinContracts { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Max Contracts", GroupName = "Sizing", Order = 3)]
        public int MaxContracts { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Kill Switch (Flatten + Stop)", GroupName = "Emergency Controls", Order = 1)]
        public bool EnableKillSwitch { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Verbose Logging", GroupName = "Debug", Order = 1)]
        public bool EnableVerboseLogging { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Enable File Logging", GroupName = "Diagnostics", Order = 10)]
        public bool EnableFileLogging { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Log Directory", GroupName = "Diagnostics", Order = 11)]
        public string LogDirectory { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Enable Long Trades", GroupName = "Trade Direction", Order = 1)]
        public bool EnableLongTrades { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Enable Short Trades", GroupName = "Trade Direction", Order = 2)]
        public bool EnableShortTrades { get; set; }

        #endregion

        // INT8ExecutionBridge implementation
        public void EnterLongManaged(int quantity, string signalName, int stopTicks, int targetTicks, double tickSize)
        {
            if (stopTicks > 0)
                SetStopLoss(signalName, CalculationMode.Ticks, stopTicks, false);
            if (targetTicks > 0)
                SetProfitTarget(signalName, CalculationMode.Ticks, targetTicks);
            EnterLong(quantity, signalName);
        }

        public void EnterShortManaged(int quantity, string signalName, int stopTicks, int targetTicks, double tickSize)
        {
            if (stopTicks > 0)
                SetStopLoss(signalName, CalculationMode.Ticks, stopTicks, false);
            if (targetTicks > 0)
                SetProfitTarget(signalName, CalculationMode.Ticks, targetTicks);
            EnterShort(quantity, signalName);
        }

        public void ExitLongManaged(string signalName)
        {
            ExitLong(signalName);
        }

        public void ExitShortManaged(string signalName)
        {
            ExitShort(signalName);
        }

        public void FlattenAll()
        {
            ExitLong("EmergencyFlatten");
            ExitShort("EmergencyFlatten");
        }

        /// <summary>
        /// Create the SDK strategy instance.
        /// </summary>
        protected abstract IStrategy CreateSdkStrategy();

        /// <summary>
        /// Configure strategy-specific values after initialization.
        /// </summary>
        protected abstract void ConfigureStrategyParameters();

        protected override void OnStateChange()
        {
            if (State == State.SetDefaults)
            {
                Description = "SDK-integrated strategy base";
                // Name intentionally not set - this is an abstract base class
                Calculate = Calculate.OnBarClose;
                EntriesPerDirection = 1;
                EntryHandling = EntryHandling.AllEntries;
                IsExitOnSessionCloseStrategy = true;
                ExitOnSessionCloseSeconds = 30;
                IsFillLimitOnTouch = false;
                MaximumBarsLookBack = MaximumBarsLookBack.TwoHundredFiftySix;
                OrderFillResolution = OrderFillResolution.Standard;
                Slippage = 0;
                StartBehavior = StartBehavior.WaitUntilFlat;
                TimeInForce = TimeInForce.Gtc;
                TraceOrders = false;
                RealtimeErrorHandling = RealtimeErrorHandling.StopCancelClose;
                StopTargetHandling = StopTargetHandling.PerEntryExecution;
                BarsRequiredToTrade = 50;

                EnableSDK = true;
                DailyLossLimit = 1000.0;
                MaxTradeRisk = 200.0;
                MaxOpenPositions = 3;
                RiskPerTrade = 100.0;
                MinContracts = 1;
                MaxContracts = 10;
                EnableKillSwitch = false;
                EnableVerboseLogging = false;
                EnableFileLogging = true;
                LogDirectory = string.Empty;
                EnableLongTrades = true;
                EnableShortTrades = true;
                _killSwitchTriggered = false;
            }
            else if (State == State.DataLoaded)
            {
                if (EnableSDK)
                {
                    try
                    {
                        InitializeSdkComponents();
                        _sdkInitialized = true;
                        Print(string.Format("[SDK] {0} initialized successfully", Name));
                    }
                    catch (Exception ex)
                    {
                        Print(string.Format("[SDK ERROR] Initialization failed: {0}", ex.Message));
                        Log(string.Format("[SDK ERROR] {0}", ex.ToString()), NinjaTrader.Cbi.LogLevel.Error);
                        _sdkInitialized = false;
                    }
                }
            }
            else if (State == State.Realtime)
            {
                InitFileLog();
                WriteSessionHeader();
            }
            else if (State == State.Terminated)
            {
                WriteSessionFooter();
            }
        }

        protected override void OnBarUpdate()
        {
            if (!_sdkInitialized || _sdkStrategy == null)
            {
                return;
            }

            if (CurrentBar < BarsRequiredToTrade)
            {
                return;
            }

            if (Time[0] == _lastBarTime)
                return;

            _lastBarTime = Time[0];

            // Kill switch — checked AFTER bar guards so ExitLong/ExitShort are valid
            if (EnableKillSwitch)
            {
                if (!_killSwitchTriggered)
                {
                    _killSwitchTriggered = true;
                    Print(string.Format("[SDK] KILL SWITCH ACTIVATED at {0} — flattening all positions.", Time[0]));
                    try
                    {
                        ExitLong("KillSwitch");
                        ExitShort("KillSwitch");
                    }
                    catch (Exception ex)
                    {
                        Print(string.Format("[SDK] Kill switch flatten error: {0}", ex.Message));
                    }
                }
                return;
            }

            // Log first processable bar and every 100th bar.
            if (CurrentBar == BarsRequiredToTrade || CurrentBar % 100 == 0)
            {
                Print(string.Format("[SDK] Processing bar {0}: {1} O={2:F2} H={3:F2} L={4:F2} C={5:F2}",
                    CurrentBar,
                    Time[0].ToString("yyyy-MM-dd HH:mm"),
                    Open[0],
                    High[0],
                    Low[0],
                    Close[0]));
            }

            try
            {
                var barData = ConvertCurrentBar();
                var context = BuildStrategyContext();

                StrategyIntent intent;
                lock (_lock)
                {
                    intent = _sdkStrategy.OnBar(barData, context);
                }

                if (intent != null)
                {
                    Print(string.Format("[SDK] Intent generated: {0} {1} @ {2}", intent.Side, intent.Symbol, intent.EntryType));
                    ProcessStrategyIntent(intent, context);
                }
            }
            catch (Exception ex)
            {
                if (_logger != null)
                    _logger.LogError("OnBarUpdate failed: {0}", ex.Message);

                Print(string.Format("[SDK ERROR] OnBarUpdate: {0}", ex.Message));
                Log(string.Format("[SDK ERROR] {0}", ex.ToString()), NinjaTrader.Cbi.LogLevel.Error);
            }
        }

        protected override void OnOrderUpdate(
            Order order,
            double limitPrice,
            double stopPrice,
            int quantity,
            int filled,
            double averageFillPrice,
            NinjaTrader.Cbi.OrderState orderState,
            DateTime time,
            ErrorCode errorCode,
            string nativeError)
        {
            if (!_sdkInitialized || _executionAdapter == null || order == null)
                return;

            if (string.IsNullOrEmpty(order.Name) || !order.Name.StartsWith("SDK_"))
                return;

            // Record NT8 rejections in circuit breaker
            if (orderState == NinjaTrader.Cbi.OrderState.Rejected && _circuitBreaker != null)
            {
                var reason = string.Format("{0} {1}", errorCode, nativeError ?? string.Empty);
                _circuitBreaker.RecordOrderRejection(reason);
                Print(string.Format("[SDK] Order rejected by NT8: {0}", reason));
            }

            _executionAdapter.ProcessOrderUpdate(
                order.OrderId,
                order.Name,
                orderState.ToString(),
                filled,
                averageFillPrice,
                (int)errorCode,
                nativeError);
        }

        protected override void OnExecutionUpdate(
            Execution execution,
            string executionId,
            double price,
            int quantity,
            MarketPosition marketPosition,
            string orderId,
            DateTime time)
        {
            if (!_sdkInitialized || _executionAdapter == null || execution == null || execution.Order == null)
                return;

            if (string.IsNullOrEmpty(execution.Order.Name) || !execution.Order.Name.StartsWith("SDK_"))
                return;

            FileLog(string.Format("FILL {0} {1} @ {2:F2} | OrderId={3}",
                execution.MarketPosition,
                execution.Quantity,
                execution.Price,
                execution.OrderId));

            _executionAdapter.ProcessExecution(orderId, executionId, price, quantity, time);
        }

        private void InitFileLog()
        {
            if (!EnableFileLogging)
                return;

            try
            {
                string dir = string.IsNullOrEmpty(LogDirectory)
                    ? System.IO.Path.Combine(
                        Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
                        "NinjaTrader 8", "log", "nt8-sdk")
                    : LogDirectory;

                System.IO.Directory.CreateDirectory(dir);

                string path = System.IO.Path.Combine(
                    dir,
                    string.Format("session_{0}.log", DateTime.Now.ToString("yyyyMMdd_HHmmss")));

                _fileLog = new System.IO.StreamWriter(path, false);
                _fileLog.AutoFlush = true;
                Print(string.Format("[NT8-SDK] File log started: {0}", path));
            }
            catch (Exception ex)
            {
                Print(string.Format("[NT8-SDK] Failed to open file log: {0}", ex.Message));
            }
        }

        private void FileLog(string message)
        {
            if (_fileLog == null)
                return;

            lock (_fileLock)
            {
                try
                {
                    _fileLog.WriteLine(string.Format("[{0:HH:mm:ss.fff}] {1}", DateTime.Now, message));
                }
                catch
                {
                }
            }
        }

        private void WriteSessionHeader()
        {
            FileLog("=== SESSION START " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " ===");
            FileLog(string.Format("Strategy   : {0}", Name));
            FileLog(string.Format("Account    : {0}", Account != null ? Account.Name : "N/A"));
            FileLog(string.Format("Symbol     : {0}", Instrument != null ? Instrument.FullName : "N/A"));
            FileLog(string.Format("Risk       : DailyLimit=${0} MaxTradeRisk=${1} RiskPerTrade=${2}",
                DailyLossLimit,
                MaxTradeRisk,
                RiskPerTrade));
            FileLog(string.Format("Sizing     : MinContracts={0} MaxContracts={1}", MinContracts, MaxContracts));
            FileLog(string.Format("VerboseLog : {0}  FileLog: {1}", EnableVerboseLogging, EnableFileLogging));
            FileLog("---");
        }

        private void WriteSessionFooter()
        {
            FileLog("---");
            FileLog("=== SESSION END " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " ===");

            if (_fileLog != null)
            {
                lock (_fileLock)
                {
                    try
                    {
                        _fileLog.Close();
                    }
                    catch
                    {
                    }

                    _fileLog = null;
                }
            }
        }

        private void InitializeSdkComponents()
        {
            _logger = new BasicLogger(Name);

            Print(string.Format("[SDK] Initializing with: DailyLoss={0:C}, TradeRisk={1:C}, MaxPos={2}",
                DailyLossLimit,
                MaxTradeRisk,
                MaxOpenPositions));

            _riskConfig = new RiskConfig(DailyLossLimit, MaxTradeRisk, MaxOpenPositions, true);
            _sizingConfig = new SizingConfig(
                SizingMethod.FixedDollarRisk,
                MinContracts,
                MaxContracts,
                RiskPerTrade,
                new Dictionary<string, object>());

            _strategyConfig = new StrategyConfig(
                Name,
                Instrument.MasterInstrument.Name,
                new Dictionary<string, object>(),
                _riskConfig,
                _sizingConfig);

            _riskManager = new BasicRiskManager(_logger);
            _positionSizer = new BasicPositionSizer(_logger);
            _circuitBreaker = new ExecutionCircuitBreaker(
                _logger,
                failureThreshold: 3,
                timeout: TimeSpan.FromSeconds(30));
            _executionAdapter = new NT8ExecutionAdapter();

            _sdkStrategy = CreateSdkStrategy();
            if (_sdkStrategy == null)
                throw new InvalidOperationException("CreateSdkStrategy returned null");

            _sdkStrategy.Initialize(_strategyConfig, null, _logger);
            ConfigureStrategyParameters();

            _ordersSubmittedToday = 0;
            _lastBarTime = DateTime.MinValue;
            _lastAccountInfo = null;
            _lastPosition = null;
            _currentSession = null;
        }

        private BarData ConvertCurrentBar()
        {
            return NT8DataConverter.ConvertBar(
                Instrument.MasterInstrument.Name,
                Time[0],
                Open[0],
                High[0],
                Low[0],
                Close[0],
                (long)Volume[0],
                (int)BarsPeriod.Value);
        }

        private StrategyContext BuildStrategyContext()
        {
            DateTime etTime;
            try
            {
                var easternZone = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
                etTime = TimeZoneInfo.ConvertTime(Time[0], easternZone);
            }
            catch
            {
                etTime = Time[0];
            }

            var customData = new Dictionary<string, object>();
            customData.Add("CurrentBar", CurrentBar);
            customData.Add("BarsRequiredToTrade", BarsRequiredToTrade);
            customData.Add("OrdersToday", _ordersSubmittedToday);

            return NT8DataConverter.ConvertContext(
                Instrument.MasterInstrument.Name,
                etTime,
                BuildPositionInfo(),
                BuildAccountInfo(),
                BuildSessionInfo(),
                customData);
        }

        private AccountInfo BuildAccountInfo()
        {
            double cashValue = 100000.0;
            double buyingPower = 250000.0;

            try
            {
                if (Account != null)
                {
                    cashValue = Account.Get(AccountItem.CashValue, Currency.UsDollar);
                    buyingPower = Account.Get(AccountItem.BuyingPower, Currency.UsDollar);
                }
            }
            catch (Exception ex)
            {
                Print(string.Format("[NT8-SDK] WARNING: Could not read live account balance, using defaults: {0}", ex.Message));
            }

            var accountInfo = NT8DataConverter.ConvertAccount(cashValue, buyingPower, 0.0, 0.0, DateTime.UtcNow);
            _lastAccountInfo = accountInfo;
            return accountInfo;
        }

        private SdkPosition BuildPositionInfo()
        {
            var p = NT8DataConverter.ConvertPosition(
                Instrument.MasterInstrument.Name,
                Position.Quantity,
                Position.AveragePrice,
                0.0,
                0.0,
                DateTime.UtcNow);

            _lastPosition = p;
            return p;
        }

        private MarketSession BuildSessionInfo()
        {
            DateTime etTime;
            try
            {
                var easternZone = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
                etTime = TimeZoneInfo.ConvertTime(Time[0], easternZone);
            }
            catch
            {
                etTime = Time[0];
            }

            var sessionStart = etTime.Date.AddHours(9).AddMinutes(30);
            var sessionEnd = etTime.Date.AddHours(16);
            var isRth = etTime.TimeOfDay >= TimeSpan.FromHours(9.5)
                        && etTime.TimeOfDay < TimeSpan.FromHours(16.0);

            _currentSession = NT8DataConverter.ConvertSession(sessionStart, sessionEnd, isRth, isRth ? "RTH" : "ETH");
            return _currentSession;
        }

        private void ProcessStrategyIntent(StrategyIntent intent, StrategyContext context)
        {
            // Direction filter — checked before risk to avoid unnecessary processing
            if (intent.Side == SdkOrderSide.Buy && !EnableLongTrades)
            {
                if (EnableVerboseLogging)
                    Print(string.Format("[SDK] Long trade filtered by direction setting: {0}", intent.Symbol));
                return;
            }
            if (intent.Side == SdkOrderSide.Sell && !EnableShortTrades)
            {
                if (EnableVerboseLogging)
                    Print(string.Format("[SDK] Short trade filtered by direction setting: {0}", intent.Symbol));
                return;
            }

            if (EnableVerboseLogging)
                Print(string.Format("[SDK] Validating intent: {0} {1}", intent.Side, intent.Symbol));

            var riskDecision = _riskManager.ValidateOrder(intent, context, _riskConfig);
            if (!riskDecision.Allow)
            {
                if (EnableVerboseLogging)
                    Print(string.Format("[SDK] Risk REJECTED: {0}", riskDecision.RejectReason));
                if (_logger != null)
                    _logger.LogWarning("Intent rejected by risk manager: {0}", riskDecision.RejectReason);
                return;
            }

            if (EnableVerboseLogging)
                Print(string.Format("[SDK] Risk approved"));

            var sizingResult = _positionSizer.CalculateSize(intent, context, _sizingConfig);
            if (EnableVerboseLogging)
            {
                Print(string.Format("[SDK] Position size: {0} contracts (min={1}, max={2})",
                    sizingResult.Contracts,
                    MinContracts,
                    MaxContracts));
            }

            if (sizingResult.Contracts < MinContracts)
            {
                if (EnableVerboseLogging)
                    Print(string.Format("[SDK] Size too small: {0} < {1}", sizingResult.Contracts, MinContracts));
                return;
            }

            var request = new OmsOrderRequest();
            request.Symbol = intent.Symbol;
            request.Side = MapOrderSide(intent.Side);
            request.Type = MapOrderType(intent.EntryType);
            request.Quantity = sizingResult.Contracts;
            request.LimitPrice = intent.LimitPrice.HasValue ? (decimal?)intent.LimitPrice.Value : null;
            request.StopPrice = null;

            if (EnableVerboseLogging)
            {
                Print(string.Format("[SDK] Submitting order: {0} {1} {2} @ {3}",
                    request.Side,
                    request.Quantity,
                    request.Symbol,
                    request.Type));
            }

            SubmitOrderToNT8(request, intent);
            _ordersSubmittedToday++;
        }

        private void SubmitOrderToNT8(OmsOrderRequest request, StrategyIntent intent)
        {
            // Circuit breaker gate
            if (State == State.Historical)
            {
                // Skip circuit breaker during backtest — wall-clock timeout is meaningless on historical data.
            }
            else if (_circuitBreaker != null && !_circuitBreaker.ShouldAllowOrder())
            {
                var state = _circuitBreaker.GetState();
                Print(string.Format("[SDK] Circuit breaker OPEN — order blocked: {0}", state.Reason));
                if (_logger != null)
                    _logger.LogWarning("Circuit breaker blocked order: {0}", state.Reason);
                return;
            }

            try
            {
                var orderName = string.Format("SDK_{0}_{1}", intent.Symbol, Guid.NewGuid().ToString("N").Substring(0, 12));

                if (EnableFileLogging)
                {
                    string grade = "N/A";
                    string score = "N/A";
                    string factors = string.Empty;

                    if (intent.Metadata != null && intent.Metadata.ContainsKey("confluence_score"))
                    {
                        var cs = intent.Metadata["confluence_score"] as NT8.Core.Intelligence.ConfluenceScore;
                        if (cs != null)
                        {
                            grade = cs.Grade.ToString();
                            score = cs.WeightedScore.ToString("F3");

                            var sb = new System.Text.StringBuilder();
                            foreach (var f in cs.Factors)
                                sb.Append(string.Format("{0}={1:F2} ", f.Type, f.Score));
                            factors = sb.ToString().TrimEnd();
                        }
                    }

                    FileLog(string.Format("SIGNAL {0} | Grade={1} | Score={2}", intent.Side, grade, score));
                    if (!string.IsNullOrEmpty(factors))
                        FileLog(string.Format("  Factors: {0}", factors));
                    FileLog(string.Format("SUBMIT {0} {1} @ Market | Stop={2} Target={3}",
                        intent.Side,
                        request.Quantity,
                        intent.StopTicks,
                        intent.TargetTicks));
                }

                _executionAdapter.SubmitOrder(request, orderName);

                if (request.Side == OmsOrderSide.Buy)
                {
                    if (request.Type == OmsOrderType.Market)
                        EnterLong(request.Quantity, orderName);
                    else if (request.Type == OmsOrderType.Limit && request.LimitPrice.HasValue)
                        EnterLongLimit(request.Quantity, (double)request.LimitPrice.Value, orderName);
                    else if (request.Type == OmsOrderType.StopMarket && request.StopPrice.HasValue)
                        EnterLongStopMarket(request.Quantity, (double)request.StopPrice.Value, orderName);
                }
                else if (request.Side == OmsOrderSide.Sell)
                {
                    if (request.Type == OmsOrderType.Market)
                        EnterShort(request.Quantity, orderName);
                    else if (request.Type == OmsOrderType.Limit && request.LimitPrice.HasValue)
                        EnterShortLimit(request.Quantity, (double)request.LimitPrice.Value, orderName);
                    else if (request.Type == OmsOrderType.StopMarket && request.StopPrice.HasValue)
                        EnterShortStopMarket(request.Quantity, (double)request.StopPrice.Value, orderName);
                }

                if (intent.StopTicks > 0)
                    SetStopLoss(orderName, CalculationMode.Ticks, (int)intent.StopTicks, false);

                if (intent.TargetTicks.HasValue && intent.TargetTicks.Value > 0)
                    SetProfitTarget(orderName, CalculationMode.Ticks, (int)intent.TargetTicks.Value);

                if (_circuitBreaker != null)
                    _circuitBreaker.OnSuccess();
            }
            catch (Exception ex)
            {
                if (_circuitBreaker != null)
                    _circuitBreaker.OnFailure();

                Print(string.Format("[SDK] SubmitOrderToNT8 failed: {0}", ex.Message));
                if (_logger != null)
                    _logger.LogError("SubmitOrderToNT8 failed: {0}", ex.Message);
                throw;
            }
        }

        private static OmsOrderSide MapOrderSide(SdkOrderSide side)
        {
            if (side == SdkOrderSide.Buy)
                return OmsOrderSide.Buy;
            return OmsOrderSide.Sell;
        }

        private static OmsOrderType MapOrderType(SdkOrderType type)
        {
            if (type == SdkOrderType.Market)
                return OmsOrderType.Market;
            if (type == SdkOrderType.Limit)
                return OmsOrderType.Limit;
            if (type == SdkOrderType.StopLimit)
                return OmsOrderType.StopLimit;
            return OmsOrderType.StopMarket;
        }

        protected OmsOrderStatus GetSdkOrderStatus(string orderName)
        {
            if (_executionAdapter == null)
                return null;
            return _executionAdapter.GetOrderStatus(orderName);
        }
    }
}