using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using TradeIdeas.TIProData;
using TradeIdeas.TIProData.Configuration;
using TradeIdeas.TIProData.Interfaces;

namespace TradeIdeas.TIProGUI.OddsMaker
{
    public partial class OddsMakerConfigWindow : Form
    {
        private IConnectionMaster _connectionMaster;
        private ISendManager _sendManager;

        /// <summary>
        /// Stores the current odds maker settings based on the user input.
        /// </summary>
        private OddsMakerConfiguration.OddsMakerConfigMemento _oddsMakerConfig = new OddsMakerConfiguration.OddsMakerConfigMemento();

        public OddsMakerConfiguration.OddsMakerConfigMemento OddsMakerConfigMemento
        {
            get { return _oddsMakerConfig; }
        }

        public IHoldOddsMakerConfig OddsMakerSettingsContainer
        {
            get { return _oddsMakerSettingsContainer; }  //we want to retrieve this item within the OddsMakerResults window before this window is closed down
        }
        public string AlertConfig
        {
            get { return _alertConfig; } //we want to retrieve this item within the OddsMakerResults window before this window is closed down
        }

        private string _targetFilterCode = "";
        private Filter _targetFilter = null;
        private bool _useTargetFilter = false;
        private string _stopFilterCode = "";
        private Filter _stopFilter = null;
        private bool _useStopFilter = false;
        private string _exitCondition = "";
        private string _alertConfig = "";
        private string _windowName = "";
        private bool _long = true;
        private OddsMakerResults _oddsMakerResults;
        private OddsMakerColumnConfiguration _columnConfigType = GuiEnvironment.OddsMakerColumnConfigType;
        private IHoldOddsMakerConfig _oddsMakerSettingsContainer;
        private FontManager _fontManager;
        private const float DEFAULT_FONT_SIZE = 9.75F; 

        /// <summary>
        /// Displays the Odds Maker configuration screen.
        /// </summary>
        /// <param name="config">Config string for alert strategy</param>
        /// <param name="connectionMaster">Connection master object</param>
        /// <param name="windowName">Window name for alert strategy</param>
        /// <param name="alertForm">AlertForm object for saving the Odds Maker settings that user selects if they actually end up performing a test.</param>
        /// <param name="oddsSetting">Default settings to be used in the form.</param>
        public OddsMakerConfigWindow(string config, IConnectionMaster connectionMaster, string windowName, IHoldOddsMakerConfig oddsMakerSettingsContainer, OddsMakerConfiguration.OddsMakerConfigMemento oddsMakerConfig)
        {
            _connectionMaster = connectionMaster;
            _sendManager = connectionMaster.SendManager;
            _alertConfig = config;
            _oddsMakerSettingsContainer = oddsMakerSettingsContainer;
            _windowName = windowName;
            _fontManager = new FontManager(this, DEFAULT_FONT_SIZE);
            _oddsMakerConfig = (OddsMakerConfiguration.OddsMakerConfigMemento)oddsMakerConfig.Clone();
            Icon = GuiEnvironment.Icon;
            _long = _oddsMakerConfig.Long;
            this.StartPosition = FormStartPosition.CenterParent;
            InitializeComponent();

            // Hide exit strategy config option for Optima users. 
            if(GuiEnvironment.OPTIMA)
            {
                radioButtonExitStrategy.Visible = false;
                buttonExitStrategyConfigure.Visible = false;
            }

            MinimizeBox = false;
            selectTheFont();
            SetSlidersMinMax();
            InitializeTimeSliders();
            InitializeRadioGroups();
            PopulateGuiFromSettings();
            UpdatePrevNextButtons();
            UpdateBacktestButtons();
            RequestFilters();
        }

        /// <summary>
        /// Requests the filters available to populate the comboboxes.
        /// </summary>
        private void RequestFilters()
        {
            ConfigurationWindowManager configManager = new ConfigurationWindowManager();
            configManager.LoadFromServer(_connectionMaster, ConfigurationType.Alerts, OnConfigLoaded, _alertConfig);
        }

        /// <summary>
        /// List of available filters from the server.  Requested upon starting this form.
        /// Sort filter list in alphabetical order.
        /// </summary>
        private List<Filter> _filters = new List<Filter>();
        private void OnConfigLoaded(ConfigurationWindowManager configManager)
        {
            _filters.Clear();
            List<Filter> filters = new List<Filter>();
            filters = configManager.FiltersInOrder.ToList<Filter>();
            // Sort list in alphabetical order
            _filters = filters.OrderBy(o => o.LongDescription).ToList();

            PopulateFilters();
        }

        private void PopulateFilters()
        {
            this.InvokeIfRequired(delegate()
            {
                comboBoxTargetFilter.DataSource = new BindingSource(_filters, null);
                comboBoxTargetFilter.DisplayMember = "LongDescription";
                comboBoxTargetFilter.ValueMember = "InternalCode";

                comboBoxStopFilter.DataSource = new BindingSource(_filters, null);
                comboBoxStopFilter.DisplayMember = "LongDescription";
                comboBoxStopFilter.ValueMember = "InternalCode";

                if (_targetFilterCode != "" && _filters.Where(x => x.InternalCode == _targetFilterCode).Count() > 0)
                {
                    Filter filter = _filters.Where(x => x.InternalCode == _targetFilterCode).First();
                    _targetFilter = filter;
                    comboBoxTargetFilter.SelectedItem = filter;
                }
                else
                    comboBoxTargetFilter.SelectedIndex = 0;

                if (_stopFilterCode != "" && _filters.Where(x => x.InternalCode == _stopFilterCode).Count() > 0)
                {
                    Filter filter = _filters.Where(x => x.InternalCode == _stopFilterCode).First();
                    _stopFilter = filter;
                    comboBoxStopFilter.SelectedItem = filter;
                }
                else
                    comboBoxStopFilter.SelectedIndex = 0;

                ReflectUserSelectionRiskManagement();
                UpdateSummaryTab();
            });
        }

        /// <summary>
        /// Updates state of buttons (colors) based on long/short
        /// </summary>
        private void UpdateBacktestButtons()
        {
            ToggleBoldFont(buttonBuy, _long);
            ToggleBoldFont(buttonSell, !_long);
        }

        /// <summary>
        /// Populate the GUI form with settings from _oddsMakerConfig
        /// </summary>
        private void PopulateGuiFromSettings()
        {
            int totalMinutesFromStart = _oddsMakerConfig.EntryHoursStart * 60 + _oddsMakerConfig.EntryMinutesStart;
            if (totalMinutesFromStart < trackBarStartTime.Minimum)
                trackBarStartTime.Value = trackBarStartTime.Minimum;
            else if (totalMinutesFromStart >= trackBarStartTime.Maximum)
                trackBarStartTime.Value = trackBarStartTime.Maximum - 1;
            else
                trackBarStartTime.Value = totalMinutesFromStart;

            int totalMinutesFromEnd = _oddsMakerConfig.EntryHoursEnd * 60 + _oddsMakerConfig.EntryMinutesEnd;
            if (totalMinutesFromEnd > 0)
                totalMinutesFromEnd = -totalMinutesFromEnd;

            DateTime startTime = GuiEnvironment.GetMarketOpenLocalTime().AddMinutes(trackBarStartTime.Value);
            DateTime endTime = GuiEnvironment.GetMarketCloseLocalTime().AddMinutes(totalMinutesFromEnd);
            if (totalMinutesFromEnd < trackBarEndTime.Minimum || startTime >= endTime)
                trackBarEndTime.Value = (int)(startTime - GuiEnvironment.GetMarketCloseLocalTime()).TotalMinutes + 1;
            else if (totalMinutesFromEnd > trackBarEndTime.Maximum)
                trackBarEndTime.Value = trackBarEndTime.Maximum;
            else
                trackBarEndTime.Value = totalMinutesFromEnd;

            int exitTimeDays = _oddsMakerConfig.ExitTimeOpenDays;
            if (_oddsMakerConfig.UseExitTimeFutureClose)
                exitTimeDays = _oddsMakerConfig.ExitTimeCloseDays;

            if (exitTimeDays > trackBarDailyExitDays.Maximum)
                trackBarDailyExitDays.Value = trackBarDailyExitDays.Maximum;
            else if (exitTimeDays < trackBarDailyExitDays.Minimum)
                trackBarDailyExitDays.Value = trackBarDailyExitDays.Minimum;
            else
                trackBarDailyExitDays.Value = exitTimeDays;

            int timeStopMinutesBeforeClose = -_oddsMakerConfig.ExitTimeMinutesBefore;
            if (timeStopMinutesBeforeClose >= trackBarTimeStop.Minimum && timeStopMinutesBeforeClose <= trackBarTimeStop.Maximum)
                trackBarTimeStop.Value = timeStopMinutesBeforeClose;
            else
                trackBarTimeStop.Value = 0;

            if (_oddsMakerConfig.ExitTimeMinutesAfter < trackBarTimeAfterEntry.Minimum)
                trackBarTimeAfterEntry.Value = trackBarTimeAfterEntry.Minimum;
            else if (_oddsMakerConfig.ExitTimeMinutesAfter > trackBarTimeAfterEntry.Maximum)
                trackBarTimeAfterEntry.Value = trackBarTimeAfterEntry.Maximum;
            else
                trackBarTimeAfterEntry.Value = _oddsMakerConfig.ExitTimeMinutesAfter;

            if (_oddsMakerConfig.DaysOfTest > trackBarTestDays.Maximum)
                trackBarTestDays.Value = trackBarTestDays.Maximum;
            else if (_oddsMakerConfig.DaysOfTest < trackBarTestDays.Minimum)
                trackBarTestDays.Value = trackBarTestDays.Minimum;
            else
                trackBarTestDays.Value = _oddsMakerConfig.DaysOfTest;

            textBoxTrailingStopPercent.Text = "";
            if (_oddsMakerConfig.ExitCondPercent.HasValue)
                textBoxTrailingStopPercent.Text = _oddsMakerConfig.ExitCondPercent.Value.ToString();

            textBoxTrailingStopBars.Text = "";
            if (_oddsMakerConfig.ExitCondBars.HasValue)
                textBoxTrailingStopBars.Text = _oddsMakerConfig.ExitCondBars.Value.ToString();

            textBoxTarget.Text = "";
            if (_oddsMakerConfig.ProfitTarget.HasValue)
                textBoxTarget.Text = _oddsMakerConfig.ProfitTarget.Value.ToString();

            _targetFilterCode = _oddsMakerConfig.TargetFilter;
            radioButtonTargetFilter.Checked = _oddsMakerConfig.UseTargetFilter;

            textBoxStopLoss.Text = "";
            if (_oddsMakerConfig.StopLoss.HasValue)
                textBoxStopLoss.Text = _oddsMakerConfig.StopLoss.Value.ToString();

            _stopFilterCode = _oddsMakerConfig.StopFilter;
            radioButtonStopLossFilter.Checked = _oddsMakerConfig.UseStopFilter;

            radioButtonDollars.Checked = _oddsMakerConfig.UseDollars;
            radioButtonNone.Checked = _oddsMakerConfig.UseNoAdvancedExit;
            radioButtonMinutesAfterEntry.Checked = _oddsMakerConfig.UseExitTimeMinutesAfter;
            radioButtonTimeOfDay.Checked = _oddsMakerConfig.UseExitAtTimeOfDay;
            rdoExitTimeFutureClose.Checked = _oddsMakerConfig.UseExitTimeFutureClose;
            rdoExitTimeFutureOpen.Checked = _oddsMakerConfig.UseExitTimeFutureOpen;
            radioButtonPercent.Checked = _oddsMakerConfig.UsePercent;
            radioButtonTrailingStopBars.Checked = _oddsMakerConfig.UseExitCondBars;
            radioButtonTrailingStopPercent.Checked = _oddsMakerConfig.UseExitCondPercent;
            radioButtonExitStrategy.Checked = _oddsMakerConfig.UseExitCondAnotherAlert;
            radioButtonExitStrategy.Enabled = _oddsMakerConfig.UseExitCondAnotherAlert;

            if (!radioButtonTimeOfDay.Checked && !rdoExitTimeFutureOpen.Checked && !rdoExitTimeFutureClose.Checked && !radioButtonMinutesAfterEntry.Checked)
                radioButtonMinutesAfterEntry.Checked = true;

            checkBoxProfitTarget.Checked = _oddsMakerConfig.UseProfitTarget;
            checkBoxStopLoss.Checked = _oddsMakerConfig.UseStopLoss;
            checkBoxWiggle.Checked = _oddsMakerConfig.UseWiggle;
            _exitCondition = _oddsMakerConfig.ExitCondition;

            SetEndTime();
            SetStartTime();
            SetDailyExitDays();
            SetTestDays();
            SetTimeAfterEntryExit();
            SetTimeStop();
            UpdateColumnConfigStatus();
        }

        private void SetTestDays()
        {
            this.InvokeIfRequired(delegate()
            {
                labelTestDays.Text = "Test Days: " + trackBarTestDays.Value.ToString();
            });
        }

        /// <summary>
        /// Sets the minimum and maximum values for all sliders in the form.
        /// </summary>
        private void SetSlidersMinMax()
        {
            trackBarDailyExitDays.Maximum = trackBarTestDays.Maximum =  GuiEnvironment.GetGeneralInfo(_connectionMaster.SendManager).GetOddsMakerDays();
            trackBarTestDays.Minimum = 1;
            labelTestDaysMax.Text = trackBarTestDays.Maximum + " days";

            DateTime marketOpenLocal = GuiEnvironment.GetMarketOpenLocalTime();
            DateTime marketCloseLocal = GuiEnvironment.GetMarketCloseLocalTime();
            TimeSpan span = marketCloseLocal - marketOpenLocal;
            int totalMinutes = (int)span.TotalMinutes;
            int minutesInTradingDay = (int)(marketCloseLocal - marketOpenLocal).TotalMinutes;

            trackBarEndTime.Maximum = 0;
            trackBarEndTime.Minimum = -totalMinutes;
            trackBarStartTime.Minimum = 0;
            trackBarStartTime.Maximum = totalMinutes;

            trackBarTimeStop.Maximum = 0;
            trackBarTimeStop.Minimum = -totalMinutes;

            trackBarTimeAfterEntry.Minimum = 1;
            trackBarTimeAfterEntry.Maximum = minutesInTradingDay;
            labelTimeAfterEntryMax.Text = minutesInTradingDay + " min";
        }

        /// <summary>
        /// Sets up the radio buttons to work together in all tabs
        /// </summary>
        private void InitializeRadioGroups()
        {
            radioButtonMinutesAfterEntry.CheckedChanged += radioButtonMinutesAfterEntry_CheckedChanged;
            radioButtonTimeOfDay.CheckedChanged += radioButtonTimeOfDay_CheckedChanged;
            rdoExitTimeFutureClose.CheckedChanged += rdoExitTimeFutureClose_CheckedChanged;
            rdoExitTimeFutureOpen.CheckedChanged += rdoExitTimeFutureOpen_CheckedChanged;

            radioButtonStopLossConstant.CheckedChanged += radioButtonStopLossConstant_CheckedChanged;
            radioButtonStopLossFilter.CheckedChanged += radioButtonStopLossFilter_CheckedChanged;

            radioButtonNone.CheckedChanged += radioButtonNone_CheckedChanged;
            radioButtonTrailingStopBars.CheckedChanged += radioButtonTrailingStopBars_CheckedChanged;
            radioButtonTrailingStopPercent.CheckedChanged += radioButtonTrailingStopPercent_CheckedChanged;
            radioButtonExitStrategy.CheckedChanged += radioButtonExitStrategy_CheckedChanged;
        }

        void radioButtonExitStrategy_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonExitStrategy.Checked)
            {
                radioButtonNone.Checked = false;
                radioButtonTrailingStopBars.Checked = false;
                radioButtonTrailingStopPercent.Checked = false;
            }
            ReflectUserSelectionAdvancedTab();
        }

        void radioButtonTrailingStopPercent_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonTrailingStopPercent.Checked)
            {
                radioButtonNone.Checked = false;
                radioButtonTrailingStopBars.Checked = false;
                radioButtonExitStrategy.Checked = false;
            }
            ReflectUserSelectionAdvancedTab();
        }

        void radioButtonTrailingStopBars_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonTrailingStopBars.Checked)
            {
                radioButtonNone.Checked = false;
                radioButtonTrailingStopPercent.Checked = false;
                radioButtonExitStrategy.Checked = false;
            }
            ReflectUserSelectionAdvancedTab();
        }

        void radioButtonNone_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonNone.Checked)
            {
                radioButtonTrailingStopBars.Checked = false;
                radioButtonTrailingStopPercent.Checked = false;
                radioButtonExitStrategy.Checked = false;
            }
            ReflectUserSelectionAdvancedTab();
        }

        void radioButtonStopLossFilter_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonStopLossFilter.Checked)
                radioButtonStopLossConstant.Checked = false;
            ReflectUserSelectionRiskManagement();
        }

        void radioButtonStopLossConstant_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonStopLossConstant.Checked)
                radioButtonStopLossFilter.Checked = false;
            ReflectUserSelectionRiskManagement();
        }

        void rdoExitTimeFutureOpen_CheckedChanged(object sender, EventArgs e)
        {
            if (rdoExitTimeFutureOpen.Checked)
            {
                rdoExitTimeFutureClose.Checked = false;
                radioButtonMinutesAfterEntry.Checked = false;
                radioButtonTimeOfDay.Checked = false;
            }
            SetDailyExitDays();
            ReflectUserSelectionTimedExits();
        }

        void rdoExitTimeFutureClose_CheckedChanged(object sender, EventArgs e)
        {
            if (rdoExitTimeFutureClose.Checked)
            {
                rdoExitTimeFutureOpen.Checked = false;
                radioButtonMinutesAfterEntry.Checked = false;
                radioButtonTimeOfDay.Checked = false;
            }
            SetDailyExitDays();
            ReflectUserSelectionTimedExits();
        }

        void radioButtonTimeOfDay_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonTimeOfDay.Checked)
            {
                rdoExitTimeFutureOpen.Checked = false;
                radioButtonMinutesAfterEntry.Checked = false;
                rdoExitTimeFutureClose.Checked = false;
            }
            ReflectUserSelectionTimedExits();
        }

        void radioButtonMinutesAfterEntry_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonMinutesAfterEntry.Checked)
            {
                rdoExitTimeFutureOpen.Checked = false;
                radioButtonTimeOfDay.Checked = false;
                rdoExitTimeFutureClose.Checked = false;
            }
            ReflectUserSelectionTimedExits();
        }

        private void InitializeTimeSliders()
        {
            trackBarStartTime.ValueChanged += new EventHandler(trackBarStartTime_ValueChanged);
            trackBarEndTime.ValueChanged += new EventHandler(trackBarEndTime_ValueChanged);
            trackBarTimeStop.Scroll += trackBarTimeStop_Scroll;
            trackBarTestDays.Scroll += trackBarTestDays_Scroll;
            trackBarDailyExitDays.Scroll += trackBarDailyExitDays_Scroll;
            trackBarTimeAfterEntry.Scroll += trackBarTimeAfterEntry_Scroll;
            SetStartTime();
            SetEndTime();
            SetTimeStop();
            SetTestDays();
            SetDailyExitDays();
            SetTimeAfterEntryExit();
            labelEndTimeMax.Text = GuiEnvironment.GetMarketCloseLocalTime().ToShortTimeString();
            labelStartTimeMax.Text = GuiEnvironment.GetMarketCloseLocalTime().ToShortTimeString();
            labelEndTimeMin.Text = GuiEnvironment.GetMarketOpenLocalTime().ToShortTimeString();
            labelStartTimeMin.Text = GuiEnvironment.GetMarketOpenLocalTime().ToShortTimeString();
            labelTimeStopMax.Text = GuiEnvironment.GetMarketCloseLocalTime().ToShortTimeString();
            labelTimeStopMin.Text = GuiEnvironment.GetMarketOpenLocalTime().ToShortTimeString();
            ReflectUserSelectionTimedExits();
        }

        void trackBarTestDays_Scroll(object sender, EventArgs e)
        {
            SetTestDays();
        }

        /// <summary>
        /// Updates gui controls enabling/disabling them based on user selection
        /// </summary>
        private void ReflectUserSelectionTimedExits()
        {
            this.InvokeIfRequired(delegate()
            {
                if (radioButtonMinutesAfterEntry.Checked)
                {
                    ToggleBoldFont(radioButtonMinutesAfterEntry, true);
                    trackBarTimeAfterEntry.Enabled = true;
                    radioButtonTimeOfDay.Checked = false;
                    ToggleBoldFont(radioButtonTimeOfDay, false);
                    rdoExitTimeFutureClose.Checked = false;
                    ToggleBoldFont(rdoExitTimeFutureClose, false);
                    rdoExitTimeFutureOpen.Checked = false;
                    ToggleBoldFont(rdoExitTimeFutureOpen, false);
                    trackBarDailyExitDays.Enabled = false;
                    trackBarTimeStop.Enabled = false;
                }
                else if (radioButtonTimeOfDay.Checked)
                {
                    ToggleBoldFont(radioButtonTimeOfDay, true);
                    trackBarTimeStop.Enabled = true;
                    trackBarTimeAfterEntry.Enabled = false;
                    radioButtonMinutesAfterEntry.Checked = false;
                    ToggleBoldFont(radioButtonMinutesAfterEntry, false);
                    rdoExitTimeFutureClose.Checked = false;
                    ToggleBoldFont(rdoExitTimeFutureClose, false);
                    rdoExitTimeFutureOpen.Checked = false;
                    ToggleBoldFont(rdoExitTimeFutureOpen, false);
                    trackBarDailyExitDays.Enabled = false;
                }
                else if (rdoExitTimeFutureClose.Checked)
                {
                    ToggleBoldFont(rdoExitTimeFutureClose, true);
                    trackBarDailyExitDays.Enabled = true;
                    radioButtonMinutesAfterEntry.Checked = false;
                    ToggleBoldFont(radioButtonMinutesAfterEntry, false);
                    radioButtonTimeOfDay.Checked = false;
                    ToggleBoldFont(radioButtonTimeOfDay, false);
                    rdoExitTimeFutureOpen.Checked = false;
                    ToggleBoldFont(rdoExitTimeFutureOpen, false);
                    trackBarTimeAfterEntry.Enabled = false;
                    trackBarTimeStop.Enabled = false;
                 }
                 else if (rdoExitTimeFutureOpen.Checked)
                {
                    ToggleBoldFont(rdoExitTimeFutureOpen, true);
                    trackBarDailyExitDays.Enabled = true;
                    radioButtonMinutesAfterEntry.Checked = false;
                    ToggleBoldFont(radioButtonMinutesAfterEntry, false);
                    radioButtonTimeOfDay.Checked = false;
                    ToggleBoldFont(radioButtonTimeOfDay, false);
                    rdoExitTimeFutureClose.Checked = false;
                    ToggleBoldFont(rdoExitTimeFutureClose, false);
                    trackBarTimeAfterEntry.Enabled = false;
                    trackBarTimeStop.Enabled = false;
                 }
            });
        }

        /// <summary>
        /// Updates gui controls enabling/disabling them based on user selection
        /// </summary>
        private void ReflectUserSelectionAdvancedTab()
        {
            this.InvokeIfRequired(delegate()
            {
                if (radioButtonNone.Checked)
                {
                    radioButtonTrailingStopBars.Checked = false;
                    radioButtonTrailingStopPercent.Checked = false;
                    radioButtonExitStrategy.Checked = false;
                    textBoxTrailingStopBars.Enabled = false;
                    textBoxTrailingStopPercent.Enabled = false;
                }
                else if (radioButtonTrailingStopBars.Checked)
                {
                    radioButtonNone.Checked = false;
                    radioButtonTrailingStopPercent.Checked = false;
                    radioButtonExitStrategy.Checked = false;
                    textBoxTrailingStopBars.Enabled = true;
                    textBoxTrailingStopPercent.Enabled = false;
                }
                else if (radioButtonTrailingStopPercent.Checked)
                {
                    radioButtonNone.Checked = false;
                    radioButtonTrailingStopBars.Checked = false;
                    radioButtonExitStrategy.Checked = false;
                    textBoxTrailingStopBars.Enabled = false;
                    textBoxTrailingStopPercent.Enabled = true;
                }
                else if (radioButtonExitStrategy.Checked)
                {
                    radioButtonNone.Checked = false;
                    radioButtonTrailingStopPercent.Checked = false;
                    radioButtonTrailingStopBars.Checked = false;
                    textBoxTrailingStopBars.Enabled = false;
                    textBoxTrailingStopPercent.Enabled = false;
                }

                if (radioButtonColumnsFromStrategy.Checked)
                    radioButtonUseAllColumns.Checked = false;
                else if (radioButtonUseAllColumns.Checked)
                    radioButtonColumnsFromStrategy.Checked = false;
            });
        }

        /// <summary>
        /// Toggles boldness of font of control.
        /// </summary>
        /// <param name="control">Control to have its font changed</param>
        /// <param name="bold">true = make bold, false = unbold</param>
        private void ToggleBoldFont(Control control, bool bold)
        {
            this.InvokeIfRequired(delegate()
            {
                if (bold)
                    control.Font = new Font(control.Font, FontStyle.Bold);
                else
                    control.Font = new Font(control.Font, FontStyle.Regular);
            });
        }

        void trackBarTimeAfterEntry_Scroll(object sender, EventArgs e)
        {
            SetTimeAfterEntryExit();
        }

        private void SetTimeAfterEntryExit()
        {
            this.InvokeIfRequired(delegate()
            {
                radioButtonMinutesAfterEntry.Text = "Minutes After Entry: " + trackBarTimeAfterEntry.Value.ToString();
            });
        }

        void trackBarDailyExitDays_Scroll(object sender, EventArgs e)
        {
            SetDailyExitDays();
        }

        private void SetDailyExitDays()
        {
            this.InvokeIfRequired(delegate()
            {
                if (rdoExitTimeFutureClose.Checked)
                {
                    rdoExitTimeFutureOpen.Text = "At Market Open";
                    if (trackBarDailyExitDays.Value == 0)
                        rdoExitTimeFutureClose.Text = "At Market Close: Tomorrow";
                    else if (trackBarDailyExitDays.Value == 1)
                        rdoExitTimeFutureClose.Text = "At Market Close: Day after Tomorrow";
                    else if (trackBarDailyExitDays.Value > 1)
                        rdoExitTimeFutureClose.Text = "At Market Close: Tomorrow + " + trackBarDailyExitDays.Value.ToString() + " days";
                }
                else if (rdoExitTimeFutureOpen.Checked)
                {
                    rdoExitTimeFutureClose.Text = "At Market Close";
                    if (trackBarDailyExitDays.Value == 0)
                        rdoExitTimeFutureOpen.Text = "At Market Open: Tomorrow";
                    else if (trackBarDailyExitDays.Value == 1)
                        rdoExitTimeFutureOpen.Text = "At Market Open: Day after Tomorrow";
                    else if (trackBarDailyExitDays.Value > 1)
                        rdoExitTimeFutureOpen.Text = "At Market Open: Tomorrow + " + trackBarDailyExitDays.Value.ToString() + " days";
                 }
            });
        }

        void trackBarTimeStop_Scroll(object sender, EventArgs e)
        {
            SetTimeStop();
        }

        private void SetTimeStop()
        {
            this.InvokeIfRequired(delegate()
            {
                DateTime currentTimeStop = GuiEnvironment.GetMarketCloseLocalTime().AddMinutes((double)trackBarTimeStop.Value);
                radioButtonTimeOfDay.Text = "Time of Day: " + currentTimeStop.ToShortTimeString();
            });
        }

        private void trackBarStartTime_ValueChanged(object sender, EventArgs e)
        {
            // starttime has min of 0, but endtime has max of zero, so we need to convert to time of day
            DateTime startTime = GuiEnvironment.GetMarketOpenLocalTime().AddMinutes(trackBarStartTime.Value);
            DateTime endTime = GuiEnvironment.GetMarketCloseLocalTime().AddMinutes(trackBarEndTime.Value);
            if (startTime >= endTime)
                trackBarStartTime.Value = (int)(endTime - GuiEnvironment.GetMarketOpenLocalTime()).TotalMinutes - 1;
            SetStartTime();
        }

        private void trackBarEndTime_ValueChanged(object sender, EventArgs e)
        {
            // starttime has min of 0, but endtime has max of zero, so we need to convert to time of day
            DateTime startTime = GuiEnvironment.GetMarketOpenLocalTime().AddMinutes(trackBarStartTime.Value);
            DateTime endTime = GuiEnvironment.GetMarketCloseLocalTime().AddMinutes(trackBarEndTime.Value);
            if (startTime >= endTime)
                trackBarEndTime.Value = (int)(startTime - GuiEnvironment.GetMarketCloseLocalTime()).TotalMinutes + 1;
            SetEndTime();
        }

        /// <summary>
        /// Gets current start time from current state of form.
        /// </summary>
        /// <returns></returns>
        private DateTime GetCurrentStartTime()
        {
            DateTime currentStartTime = GuiEnvironment.GetMarketOpenLocalTime().AddMinutes((double)trackBarStartTime.Value);
            return currentStartTime;
        }

        private void SetStartTime()
        {
            this.InvokeIfRequired(delegate()
            {
                DateTime currentStartTime = GetCurrentStartTime();
                labelStartTimeValue.Text = "Start Time: " + currentStartTime.ToShortTimeString();
            });
        }

        /// <summary>
        /// Gets current start time from current state of form.
        /// </summary>
        /// <returns></returns>
        private DateTime GetCurrentEndTime()
        {
            DateTime currentEndTime = GuiEnvironment.GetMarketCloseLocalTime().AddMinutes((double)trackBarEndTime.Value);
            return currentEndTime;
        }

        private void SetEndTime()
        {
            this.InvokeIfRequired(delegate()
            {
                DateTime currentEndTime = GetCurrentEndTime();
                labelEndTimeValue.Text = "End Time: " + currentEndTime.ToShortTimeString();
            });
        }

        private void buttonBuy_Click(object sender, EventArgs e)
        {
            GuiEnvironment.RecordUseCase("OddsMakerConfig.Button.SimulateBuy", _sendManager);
            DialogResult = System.Windows.Forms.DialogResult.OK;
            PerformBacktest(true);
        }

        private void buttonSell_Click(object sender, EventArgs e)
        {
            GuiEnvironment.RecordUseCase("OddsMakerConfig.Button.SimulateSell", _sendManager);
            DialogResult = System.Windows.Forms.DialogResult.OK;
            PerformBacktest(false);
        }

        /// <summary>
        /// Actually perform the backtest.
        /// </summary>
        /// <param name="isLong">Simulate going long or short (long = true, short = false).</param>
        private void PerformBacktest(bool isLong)
        {
            OddsMakerConfiguration.OddsMakerConfigMemento oddsMakerSettings = GetSettingsFromGui();
            oddsMakerSettings.Long = isLong;
            _oddsMakerSettingsContainer.SetOddsMakerSettings(oddsMakerSettings);
            OddsMakerRequest request = GetRequestFromGui();
            request.SuccessDirectionUp = isLong;
            tabControlMain.SelectedTab = tabPageSummary;
            _oddsMakerResults = new OddsMakerResults(request, _connectionMaster, this, _windowName, oddsMakerSettings);
        }

        /// <summary>
        /// Left over from original OddsMakerConfiguration window.
        /// </summary>
        public void selectTheFont()
        {
            _fontManager.selectTheFont();
        }

        public void restoreDefault(OddsMakerConfiguration.OddsMakerConfigMemento oddsMakerSettings)
        {
            _oddsMakerConfig = oddsMakerSettings;
        }

        public void setUserOddsSettings(OddsMakerConfiguration.OddsMakerConfigMemento oddsMakerSettings)
        {
            _oddsMakerConfig = oddsMakerSettings;
        }

        private OddsMakerConfiguration.OddsMakerConfigMemento GetSettingsFromGui()
        {
            OddsMakerConfiguration.OddsMakerConfigMemento oddsMakerConfig = new OddsMakerConfiguration.OddsMakerConfigMemento();
            oddsMakerConfig.Long = _long;
            oddsMakerConfig.ExitTimeCloseDays = trackBarDailyExitDays.Value;
            oddsMakerConfig.ExitTimeOpenDays = trackBarDailyExitDays.Value;
            oddsMakerConfig.ExitTimeMinutesBefore = -trackBarTimeStop.Value;
            oddsMakerConfig.ExitTimeMinutesAfter = trackBarTimeAfterEntry.Value;
            oddsMakerConfig.EntryHoursStart = 0;
            oddsMakerConfig.EntryMinutesStart = trackBarStartTime.Value;
            oddsMakerConfig.EntryHoursEnd = 0;
            oddsMakerConfig.EntryMinutesEnd = -trackBarEndTime.Value;
            oddsMakerConfig.DaysOfTest = trackBarTestDays.Value;

            double exitConditionPercent = 0;
            if ("" != textBoxTrailingStopPercent.Text && double.TryParse(textBoxTrailingStopPercent.Text, out exitConditionPercent))
                oddsMakerConfig.ExitCondPercent = exitConditionPercent;

            double exitConditionBars = 0;
            if ("" != textBoxTrailingStopBars.Text && double.TryParse(textBoxTrailingStopBars.Text, out exitConditionBars))
                oddsMakerConfig.ExitCondBars = exitConditionBars;

            double profitTarget = 0;
            if ("" != textBoxTarget.Text && double.TryParse(textBoxTarget.Text, out profitTarget))
                oddsMakerConfig.ProfitTarget = profitTarget;

            double stopLoss = 0;
            if ("" != textBoxStopLoss.Text && double.TryParse(textBoxStopLoss.Text, out stopLoss))
                oddsMakerConfig.StopLoss = stopLoss;

            oddsMakerConfig.ByAtLeastDollars = 0.01;
            oddsMakerConfig.ByAtLeastPerCent = 0.01;
            oddsMakerConfig.UseDollars = radioButtonDollars.Checked;
            oddsMakerConfig.UsePercent = radioButtonPercent.Checked;
            oddsMakerConfig.UseNoAdvancedExit = radioButtonNone.Checked;
            oddsMakerConfig.UseExitTimeMinutesAfter = radioButtonMinutesAfterEntry.Checked;
            oddsMakerConfig.UseExitAtTimeOfDay = radioButtonTimeOfDay.Checked;
            oddsMakerConfig.UseExitTimeFutureClose = rdoExitTimeFutureClose.Checked;
            oddsMakerConfig.UseExitTimeFutureOpen = rdoExitTimeFutureOpen.Checked;
            oddsMakerConfig.UseExitCondPercent = radioButtonTrailingStopPercent.Checked;
            oddsMakerConfig.UseExitCondBars = radioButtonTrailingStopBars.Checked;
            oddsMakerConfig.UseExitCondAnotherAlert = radioButtonExitStrategy.Checked;
            oddsMakerConfig.UseProfitTarget = checkBoxProfitTarget.Checked;
            oddsMakerConfig.UseStopLoss = checkBoxStopLoss.Checked;
            oddsMakerConfig.UseWiggle = checkBoxWiggle.Checked;
            oddsMakerConfig.cboLocation = 0;
            oddsMakerConfig.ExitCondition = _exitCondition;

            if (radioButtonStopLossFilter.Checked && comboBoxStopFilter.SelectedValue != null)
            {
                _useStopFilter = true;
                Filter filter = comboBoxStopFilter.SelectedItem as Filter;
                if (null != filter)
                {
                    _stopFilterCode = filter.InternalCode;
                    _stopFilter = filter;
                    oddsMakerConfig.StopFilter = _stopFilterCode;
                }
            }
            else
                _useStopFilter = false;
            oddsMakerConfig.UseStopFilter = _useStopFilter;

            if (radioButtonTargetFilter.Checked && comboBoxTargetFilter.SelectedValue != null)
            {
                _useTargetFilter = true;
                Filter filter = comboBoxTargetFilter.SelectedItem as Filter;
                if (null != filter)
                {
                    _targetFilterCode = filter.InternalCode;
                    _targetFilter = filter;
                    oddsMakerConfig.TargetFilter = _targetFilterCode;
                }
            }
            else
                _useTargetFilter = false;
            oddsMakerConfig.UseTargetFilter = _useTargetFilter;

            return oddsMakerConfig;
        }

        private OddsMakerRequest GetRequestFromGui()
        {
            OddsMakerRequest request = new OddsMakerRequest();
            request.EntryCondition = _alertConfig;
            request.DaysOfTest = trackBarTestDays.Value;
            request.SkipDays = 0;
            request.ColumnConfig = _columnConfigType;
            request.EntryTimeEnd = -trackBarEndTime.Value;
            request.EntryTimeStart = trackBarStartTime.Value;
            request.Location = SelectedLocation.US;
            if (checkBoxProfitTarget.Checked)
            {
                Filter selectedTargetFilter = comboBoxTargetFilter.SelectedItem as Filter;
                if (null != selectedTargetFilter && radioButtonTargetFilter.Checked)
                {
                    request.TargetFilter = selectedTargetFilter.InternalCode;
                    request.UseTargetFilter = true;
                }
                else
                {
                    double number;
                    if (Double.TryParse(textBoxTarget.Text, out number))
                        request.ProfitTarget = number;
                    else
                        request.ProfitTarget = 1;
                }
            }
            else
                request.ProfitTarget = null;

            if (checkBoxStopLoss.Checked)
            {
                Filter selectedStopFilter = comboBoxStopFilter.SelectedItem as Filter;
                if (null != selectedStopFilter && radioButtonStopLossFilter.Checked)
                {
                    request.StopFilter = selectedStopFilter.InternalCode;
                    request.UseStopFilter = true;
                }
                else
                {
                    double number;
                    if (Double.TryParse(textBoxStopLoss.Text, out number))
                        request.StopLoss = number;
                    else
                        request.StopLoss = 1;
                }
            }
            else
                request.StopLoss = null;

            request.StopLossWiggle = checkBoxWiggle.Checked;

            request.SuccessMinMove = 0.01;
            request.SuccessTypePercent = radioButtonPercent.Checked;

            if (radioButtonMinutesAfterEntry.Checked)
            {
                request.TimeoutType = TimeoutType.MinutesAfterEntry;
                request.TimeoutMinutes = trackBarTimeAfterEntry.Value;
            }
            else if (radioButtonTimeOfDay.Checked)
            {
                request.TimeoutType = TimeoutType.Close;
                request.BeforeCloseMinutes = -trackBarTimeStop.Value;
            }
            else if (rdoExitTimeFutureOpen.Checked)
            {
                request.TimeoutType = TimeoutType.Open;
                request.AtOpenDays = trackBarDailyExitDays.Value;
            }
            else if (rdoExitTimeFutureClose.Checked)
            {
                request.TimeoutType = TimeoutType.FutureClose;
                request.AtCloseDays = trackBarDailyExitDays.Value;
            }
            else
            {
                request.TimeoutType = TimeoutType.MinutesAfterEntry;
                request.TimeoutMinutes = trackBarTimeAfterEntry.Value;
            }
            request.XmlMode = true;
            request.ExitConditionAlert = _exitCondition;

            if (radioButtonTrailingStopPercent.Checked)
            {
                double number;
                if (Double.TryParse(textBoxTrailingStopPercent.Text, out number))
                    request.ExitConditionTrailingStop = number;
                else
                    request.ExitConditionTrailingStop = 0.5;
                request.ExitConditionType = ExitConditionType.TrailingPercent;
            }
            else if (radioButtonTrailingStopBars.Checked)
            {
                double number;
                if (Double.TryParse(textBoxTrailingStopBars.Text, out number))
                    request.ExitConditionTrailingStop = number;
                else
                    request.ExitConditionTrailingStop = 0.5; // Set to default
                request.ExitConditionType = ExitConditionType.TrailingBars;
            }
            else if (radioButtonExitStrategy.Checked)
            {
                request.ExitConditionAlert = _exitCondition;
                request.ExitConditionType = ExitConditionType.Alert;
            }
            else
                request.ExitConditionType = ExitConditionType.None;

            request.RequestCsvFile = true;
            return request;
        }

        /// <summary>
        /// Enables/disables gui controls based on user selection in the Risk Management tab.
        /// </summary>
        private void ReflectUserSelectionRiskManagement()
        {
            this.InvokeIfRequired(delegate()
            {
                if (radioButtonDollars.Checked)
                {
                    labelTargetConstantLabel.Text = "$";
                    labelStopLossConstantLabel.Text = "$";
                }
                else
                {
                    labelTargetConstantLabel.Text = "%";
                    labelStopLossConstantLabel.Text = "%";
                }

                if (checkBoxProfitTarget.Checked)
                {
                    radioButtonTargetConstant.Enabled = true;
                    radioButtonTargetFilter.Enabled = true;
                    comboBoxTargetFilter.Enabled = radioButtonTargetFilter.Checked;
                    textBoxTarget.Enabled = radioButtonTargetConstant.Checked;
                    labelTargetConstantLabel.Enabled = radioButtonTargetConstant.Checked;
                }
                else
                {
                    radioButtonTargetConstant.Enabled = false;
                    radioButtonTargetFilter.Enabled = false;
                    comboBoxTargetFilter.Enabled = false;
                    textBoxTarget.Enabled = false;
                    labelTargetConstantLabel.Enabled = false;
                }

                if (checkBoxStopLoss.Checked)
                {
                    radioButtonStopLossConstant.Enabled = true;
                    radioButtonStopLossFilter.Enabled = true;
                    comboBoxStopFilter.Enabled = radioButtonStopLossFilter.Checked;
                    textBoxStopLoss.Enabled = radioButtonStopLossConstant.Checked;
                    checkBoxWiggle.Enabled = radioButtonStopLossConstant.Checked;
                    labelStopLossConstantLabel.Enabled = radioButtonStopLossConstant.Checked;
                }
                else
                {
                    radioButtonStopLossConstant.Enabled = false;
                    radioButtonStopLossFilter.Enabled = false;
                    comboBoxStopFilter.Enabled = false;
                    textBoxStopLoss.Enabled = false;
                    checkBoxWiggle.Enabled = false;
                    labelStopLossConstantLabel.Enabled = false;
                }

                if (!radioButtonStopLossFilter.Checked && !radioButtonStopLossConstant.Checked)
                    radioButtonStopLossConstant.Checked = true;

                if (!radioButtonTargetFilter.Checked && !radioButtonTargetConstant.Checked)
                    radioButtonTargetConstant.Checked = true;
            });
        }

        private void radioButtonDollars_CheckedChanged(object sender, EventArgs e)
        {
            ReflectUserSelectionRiskManagement();
        }

        private void radioButtonPercent_CheckedChanged(object sender, EventArgs e)
        {
            ReflectUserSelectionRiskManagement();
        }

        private void checkBoxProfitTarget_CheckedChanged(object sender, EventArgs e)
        {
            ReflectUserSelectionRiskManagement();
        }

        private void radioButtonTargetConstant_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonTargetConstant.Checked)
                radioButtonTargetFilter.Checked = !radioButtonTargetConstant.Checked;
            ReflectUserSelectionRiskManagement();
        }

        private void radioButtonTargetFilter_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonTargetFilter.Checked)
                radioButtonTargetConstant.Checked = !radioButtonTargetFilter.Checked;
            ReflectUserSelectionRiskManagement();
        }

        private void checkBoxStopLoss_CheckedChanged(object sender, EventArgs e)
        {
            ReflectUserSelectionRiskManagement();
        }

        private void buttonCancel_Click(object sender, EventArgs e)
        {
            Close();
        }

        private void buttonPrevious_Click(object sender, EventArgs e)
        {
            if (tabControlMain.SelectedTab == tabPageSummary)
                tabControlMain.SelectedTab = tabPageAdvanced;
            else if (tabControlMain.SelectedTab == tabPageAdvanced)
                tabControlMain.SelectedTab = tabPageRiskMgmt;
            else if (tabControlMain.SelectedTab == tabPageRiskMgmt)
                tabControlMain.SelectedTab = tabPageTimedExit;
            else if (tabControlMain.SelectedTab == tabPageTimedExit)
                tabControlMain.SelectedTab = tabPageEntry;
            UpdatePrevNextButtons();
        }

        private void buttonNext_Click(object sender, EventArgs e)
        {
            if (tabControlMain.SelectedTab == tabPageEntry)
                tabControlMain.SelectedTab = tabPageTimedExit;
            else if (tabControlMain.SelectedTab == tabPageTimedExit)
                tabControlMain.SelectedTab = tabPageRiskMgmt;
            else if (tabControlMain.SelectedTab == tabPageRiskMgmt)
                tabControlMain.SelectedTab = tabPageAdvanced;
            else if (tabControlMain.SelectedTab == tabPageAdvanced)
                tabControlMain.SelectedTab = tabPageSummary;
            UpdatePrevNextButtons();
        }

        /// <summary>
        /// Updates enabled state of previous and next buttons based on currently selected tab.
        /// </summary>
        private void UpdatePrevNextButtons()
        {
            buttonPrevious.Enabled = tabControlMain.SelectedTab != tabPageEntry;
            buttonNext.Enabled = tabControlMain.SelectedTab != tabPageSummary;
        }

        /// <summary>
        /// Updates summary tab to reflect current state of user selections on the form.
        /// </summary>
        private void UpdateSummaryTab()
        {
            this.InvokeIfRequired(delegate()
            {
                OddsMakerConfiguration.OddsMakerConfigMemento oddsMakerSettings = GetSettingsFromGui();
                labelInitiateTradesValue.Text = GetCurrentStartTime().ToShortTimeString() + " - " + GetCurrentEndTime().ToShortTimeString();

                if (oddsMakerSettings.UseExitTimeMinutesAfter)
                    labelTimedExitValue.Text = oddsMakerSettings.ExitTimeMinutesAfter.ToString() + " minutes after entry";
                else if (oddsMakerSettings.UseExitAtTimeOfDay)
                    labelTimedExitValue.Text = GuiEnvironment.GetMarketCloseLocalTime().AddMinutes(-oddsMakerSettings.ExitTimeMinutesBefore).ToShortTimeString();
                else if (oddsMakerSettings.UseExitTimeFutureClose)
                    labelTimedExitValue.Text = "At close after " + oddsMakerSettings.ExitTimeCloseDays.ToString() + " days";
                else if (oddsMakerSettings.UseExitTimeFutureOpen)
                    labelTimedExitValue.Text = "At open after " + oddsMakerSettings.ExitTimeOpenDays.ToString() + " days";
                else
                    labelTimedExitValue.Text = "None";

                string dollarsText = "";
                string percentText = "";
                if (oddsMakerSettings.UsePercent)
                    percentText = "%";
                if (oddsMakerSettings.UseDollars)
                    dollarsText = "$";

                if (oddsMakerSettings.UseStopLoss)
                {
                    if (oddsMakerSettings.UseStopFilter)
                    {
                        if (null != _stopFilter)
                            labelStopLossExitValue.Text = _stopFilter.LongDescription;
                        else
                            labelStopLossExitValue.Text = _stopFilterCode;
                    }
                    else if (oddsMakerSettings.StopLoss.HasValue)
                    {
                        string wiggleText = "";
                        if (oddsMakerSettings.UseWiggle)
                            wiggleText = " + Wiggle";
                        labelStopLossExitValue.Text = dollarsText + oddsMakerSettings.StopLoss.Value.ToString() + percentText + wiggleText;
                    }
                    else
                        labelStopLossExitValue.Text = "Unknown";
                }
                else
                    labelStopLossExitValue.Text = "None";

                if (oddsMakerSettings.UseProfitTarget)
                {
                    if (oddsMakerSettings.UseTargetFilter)
                    {
                        if (null != _targetFilter)
                            labelProfitTargetExitValue.Text = _targetFilter.LongDescription;
                        else
                            labelProfitTargetExitValue.Text = _targetFilterCode;
                    }
                    else if (oddsMakerSettings.ProfitTarget.HasValue)
                        labelProfitTargetExitValue.Text = dollarsText + oddsMakerSettings.ProfitTarget.Value.ToString() + percentText;
                    else
                        labelProfitTargetExitValue.Text = "Unknown";
                }
                else
                    labelProfitTargetExitValue.Text = "None";

                if (oddsMakerSettings.UseNoAdvancedExit)
                    labelAdvancedExitValue.Text = "None";
                else if (oddsMakerSettings.UseExitCondPercent && oddsMakerSettings.ExitCondPercent.HasValue)
                    labelAdvancedExitValue.Text = oddsMakerSettings.ExitCondPercent.Value.ToString() + " trailing stop %";
                else if (oddsMakerSettings.UseExitCondBars && oddsMakerSettings.ExitCondBars.HasValue)
                    labelAdvancedExitValue.Text = oddsMakerSettings.ExitCondBars.Value.ToString() + " trailing bars";
                else if (oddsMakerSettings.ExitCondition != "")
                    labelAdvancedExitValue.Text = "Alert Exit";
                else
                    labelAdvancedExitValue.Text = "None";

                labelTestDaysValue.Text = trackBarTestDays.Value.ToString() + " days";
             });
        }

        private void tabControlMain_SelectedIndexChanged(object sender, EventArgs e)
        {
            UpdateSummaryTab();
            UpdatePrevNextButtons();
        }

        private void radioButtonColumnsFromStrategy_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonColumnsFromStrategy.Checked)
            {
                radioButtonUseAllColumns.Checked = false;
                if (_columnConfigType != OddsMakerColumnConfiguration.Strategy)
                    _columnConfigType = OddsMakerColumnConfiguration.Strategy;
            }
            UpdateColumnConfigStatus();
        }

        private void radioButtonColumnsFavorites_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButtonUseAllColumns.Checked)
            {
                radioButtonColumnsFromStrategy.Checked = false;
                if (_columnConfigType != OddsMakerColumnConfiguration.Favorites)
                    _columnConfigType = OddsMakerColumnConfiguration.Favorites;
            }
            UpdateColumnConfigStatus();
        }

        private void UpdateColumnConfigStatus()
        {
            radioButtonColumnsFromStrategy.Checked = _columnConfigType == OddsMakerColumnConfiguration.Strategy;
            radioButtonUseAllColumns.Checked = _columnConfigType == OddsMakerColumnConfiguration.Favorites;

            GuiEnvironment.OddsMakerColumnConfigType = _columnConfigType;
        }

        private void buttonSetFavorites_Click(object sender, EventArgs e)
        {
            string initialString = "O=8000000000000000000000000_41D_0&WN=My+Alerts" + GetColumnConfig(GuiEnvironment.OddsMakerFavoriteFilters);

            ConfigWindowWrapper configWindowWrapper = ConfigWindowWrapper.DefaultFactory(ConfigurationType.Alerts, _connectionMaster);
            configWindowWrapper.InitialConfig = initialString;
            configWindowWrapper.OnlyShowColumns = true;
            configWindowWrapper.UsingOddsMaker = true;
            configWindowWrapper.UseCaseName = "OddsColumns";
            configWindowWrapper.ShowIt();
            if (!configWindowWrapper.Canceled)
                GuiEnvironment.OddsMakerFavoriteFilters = configWindowWrapper.Strategy.Columns.Select(x => x.InternalCode).ToList<string>();
        }

        /// <summary>
        /// Returns a formatted string for use in GuiEnvironment.OddsMakerFavoriteFilters.
        /// </summary>
        /// <param name="columns">List of filters by InternalCode.</param>
        /// <returns>string representation.  e.g. show0=Price&show1=RV</returns>
        private string GetColumnConfig(List<string> columns)
        {
            int index = 0;
            StringBuilder config = new StringBuilder();
            foreach (string internalCode in columns)
            {
                config.Append("&show");
                config.Append(index);
                index++;
                config.Append("=");
                config.Append(internalCode);
            }
            config.Append("&show");
            config.Append(index);
            index++;
            config.Append('=');
            return config.ToString();
        }

        private void buttonExitStrategyConfigure_Click(object sender, EventArgs e)
        {
            GuiEnvironment.RecordUseCase("OddsMakerConfig.Button.Configure", _sendManager);
            ConfigWindowWrapper configWindowWrapper = ConfigWindowWrapper.DefaultFactory(ConfigurationType.Alerts, _connectionMaster);
            configWindowWrapper.InitialConfig = _exitCondition;
            configWindowWrapper.HideColumns = true;
            configWindowWrapper.UseCaseName = "Odds";
            configWindowWrapper.NotAWindow = true;
            configWindowWrapper.ShowIt();
            if (!configWindowWrapper.Canceled)
            {
                _exitCondition = configWindowWrapper.Strategy.MakeConfigString();
                radioButtonExitStrategy.Enabled = true;
                radioButtonExitStrategy.Checked = true;
            }
        }

        private void OddsMakerConfigWindow_FormClosing(object sender, FormClosingEventArgs e)
        {
            this.Dispose(); //we're not hiding this window.. instead it shall be closed.
        }
    }
}