using System;
using System.Collections.Generic;
using System.Linq;
using TradeIdeas.Extensions;
using System.Windows.Forms;
using TradeIdeas.TIProGUI;
using System.Threading;
using TradeIdeas.TIProData;
using System.Xml;
using TradeIdeas.MiscSupport;
using System.Reflection;
using TradeIdeas.ServerConnection;
using TradeIdeas.XML;

namespace TIProDevExtension
{
    public class Warning : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new Warning());
            return result;
        }

        public void MainInit()
        {
            //CustomEoC.RegisterLayout();
            // Interesting.  This seems to go away at the same time as the splash screen.
            // Comment out MessageBox.  This causes the default layout to load slowly and
            // slows down the authorization status for premium content.
            // MessageBox.Show("You are running an early development version of TI Pro.", "Here be Dragons");
        }
    }

    public class MarketSummaryHistogramExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new MarketSummaryHistogramExtension((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private MarketSummaryHistogramExtension(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("User Friendly Market Summary Histogram", delegate
            {
                new MarketSummaryHistogram(_mainProgram.ConnectionMaster).Show();
            });
            _mainProgram.AddToToolsMenu("SEC Market Master (w/ drop down)", delegate
            {
                new MarketMaster(_mainProgram.ConnectionMaster).Show();
            });
            _mainProgram.AddToToolsMenu("SEC Market Master (for developers)", delegate
            {
                new MarketMaster2(_mainProgram.ConnectionMaster).Show();
            });
            MarketMaster2.RegisterLayout();
        }
    }

    public class HistogramHistoryDownloader : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new HistogramHistoryDownloader((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private HistogramHistoryDownloader(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Histogram History Downloader...", delegate
            {
                new HistogramHistoryForm(_mainProgram.ConnectionMaster).Show();
            });
         }
    }

    public class ClearPaperTradingAccount : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new ClearPaperTradingAccount((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private ClearPaperTradingAccount(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Clear Simulated Trading Account...", delegate
            {
                DialogResult result = MessageBox.Show("Are you sure you want to clear all your data in your simulated trading account? This can't be undone.", "Confirm Simuulated Trading Reset", MessageBoxButtons.OKCancel);
                if (result == DialogResult.OK)
                {
                    object[] message = new object[]
                        {
                    "command", "paper_command",
                    "subcommand", "paper_clear_account",
                        };
                    Dictionary<string, byte[]> messageToSend = TalkWithServer.CreateMessage(message);
                    _mainProgram.ConnectionMaster.SendManager.SendMessage(messageToSend, PaperMessageReceived, false);
                }
            });
        }

        private void PaperMessageReceived(byte[] body, object clientId)
        {
            if (null == body) { }
            else
            {
                string debugView = System.Text.Encoding.UTF8.GetString(body);
                XmlNode message = XmlHelper.Get(body).Node(0);
                string type = message.Property("type", "");
                if (type == "account_clear")
                    MessageBox.Show("Simulated account cleared successfully - please disconnect and reconnect to simulated trading.");
            }
         }
    }

    public class HolidayTesterWindow : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new HolidayTesterWindow((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private HolidayTesterWindow(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Holiday Tester...", delegate
            {
                new HolidayTester().Show();
            });
         }
    }

    public class WhyNoMatchWindow : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new WhyNoMatchWindow((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private WhyNoMatchWindow(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Why No Match Window...", delegate
            {
                OpenFormChooser openFormChooser = new OpenFormChooser();
                DialogResult result = openFormChooser.ShowDialog();
                if (result == DialogResult.OK)
                {
                    if (openFormChooser.RunHistory)
                    {
                        foreach (AlertForm alertForm in openFormChooser.CheckedAlertForms)
                        {
                            alertForm.SetConfigHistory(alertForm.GetConfigString(), openFormChooser.StartTime, openFormChooser.EndTime);
                        }
                    }
                    else
                    {
                        foreach (AlertForm alertForm in openFormChooser.CheckedAlertForms)
                        {
                            new WhyNoMatch(alertForm, openFormChooser.Symbol, openFormChooser.FilterToColumns);
                        }

                        foreach (MultiStrategy multiStrategy in openFormChooser.CheckedMultiStrategyForms)
                        {
                            new WhyNoMatch(multiStrategy, openFormChooser.Symbol, openFormChooser.FilterToColumns);
                        }
                    }
                }
            });
         }
    }

    public class MonitorServerMessagesExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new MonitorServerMessagesExtension((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private MonitorServerMessagesExtension(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Monitor Server Messages", delegate
            {
                new MonitorServerMessages(_mainProgram.ConnectionMaster).Show();
            });
        }
    }

    public class TimerTestExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new TimerTestExtension((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private TimerTestExtension(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Timer Testing", delegate
            {
                new TimerTesting().Show();
            });
        }
    }

    public class TimeZoneTestExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<Object>(1);
            result.Add(new TimeZoneTestExtension((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private TimeZoneTestExtension(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Time Zone Tester", delegate
            {
                new TimeZoneTesterForm().Show();
            });
        }
    }

    /// <summary>
    /// I got tired of creating a new IMainInit class for each window.  Most of these
    /// extensions are trivial and there was a lot of boilerplate code.  This class
    /// lets you add stuff when the program first initializes.
    /// </summary>
    public class SimpleExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<Object>(1);
            result.Add(new SimpleExtension((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private SimpleExtension(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            TradeIdeas.TIProGUI.Surfer.SurfManager _surfManager = null;
            ToolStripMenuItem _surfManagerMenuItem = null;
            _surfManagerMenuItem = _mainProgram.AddToToolsMenu("Start Surfing!", delegate
            {
                if (null == _surfManager)
                    _surfManager = TradeIdeas.TIProGUI.Surfer.SurfManager.Instance();
                _surfManager.Started += delegate
                {
                    _surfManagerMenuItem.Checked = true;
                };
                _surfManager.Stopped += delegate
                {
                    _surfManagerMenuItem.Checked = false;
                };

                if (_surfManager.IsRunning)
                    _surfManager.Stop();
                else
                    _surfManager.Start();

                _surfManagerMenuItem.Checked = _surfManager.IsRunning;
            });
            _mainProgram.AddToToolsMenu("StockData test", delegate
            {
                new StockDataTester().Show();
            });
            _mainProgram.AddToToolsMenu("DataNode Control Editor", delegate
            {
                new ValueEditor.ControlEditor().Show();
            });
            _mainProgram.AddToToolsMenu("Get Layout From Server", GetLayoutFromServer);
        }

        Form dummy_form = new Form();
        private void GetLayoutFromServer()
        {
            // Need form so that LoadFromCloudRequest will work
            dummy_form.Show();
            dummy_form.Hide();
            var message = TalkWithServer.CreateMessage("command", "misc_command", "subcommand", "get_default_layout");
            _mainProgram.ConnectionMaster.SendManager.SendMessage(message, Response);
        }

        private void Response(byte[] body, object clientId)
        {
            XmlNode node = XmlHelper.Get(body).Node("API");
            if (null != node)
            {
                String default_layout_code = "code=" + node.Property("share_code", "");
                new LoadFromCloudRequest(_mainProgram.ConnectionMaster.SendManager, default_layout_code, dummy_form);
            }
            System.Diagnostics.Debug.WriteLine("get_default_layout -> "
                + ((null == body) ? "null" : TalkWithServer.BytesToStr(body)));
        }
    }

    public class CustomChannelExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<Object>(1);
            result.Add(new CustomChannelExtension((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private CustomChannelExtension(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("** Custom Channel", delegate
            {
                var message = TalkWithServer.CreateMessage("command", "custom_channels_command", "subcommand", "julio_test_xml", "magic", "abracadabra");
                _mainProgram.ConnectionMaster.SendManager.SendMessage(message, Response);
            });
        }

        private void Response(byte[] body, object clientId)
        {
            System.Diagnostics.Debug.WriteLine("julio_test -> "
                + ((null == body) ? "null" : TalkWithServer.BytesToStr(body)));
        }
    }

    public class RoboHistoryExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<Object>(1);
            result.Add(new RoboHistoryExtension((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private RoboHistoryExtension(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Robo History", delegate
            {
                new RoboHistory(_mainProgram.ConnectionMaster).Show();
            });
        }
    }

    //public class CustomEoCExtension : IMainInit
    //{
    //    public static IList<Object> GetExtensions(Object mainProgram)
    //    {
    //        List<Object> result = new List<object>(1);
    //        result.Add(new CustomEoCExtension((IMainProgram)mainProgram));
    //        return result;
    //    }

    //    private readonly IMainProgram _mainProgram;
    //    private CustomEoCExtension(IMainProgram mainProgram)
    //    {
    //        _mainProgram = mainProgram;            
    //    }

    //    private ToolStripMenuItem toolStripRBI5;
    //    private ToolStripMenuItem toolStripRBI15;
    //    private ToolStripMenuItem toolStripRBI30;
    //    private ToolStripMenuItem toolStripGBI5;
    //    private ToolStripMenuItem toolStripGBI15;
    //    private ToolStripMenuItem toolStripGBI30;
    //    private ToolStripMenuItem toolStripFakeData;

    //    public void MainInit()
    //    {
    //        toolStripRBI5 = new ToolStripMenuItem("RBI 5");
    //        toolStripRBI15 = new ToolStripMenuItem("RBI 15");
    //        toolStripRBI30 = new ToolStripMenuItem("RBI 30");
    //        toolStripGBI5 = new ToolStripMenuItem("GBI 5");
    //        toolStripGBI15 = new ToolStripMenuItem("GBI 15");
    //        toolStripGBI30 = new ToolStripMenuItem("GBI 30");
    //        toolStripFakeData = new ToolStripMenuItem("Generate Fake Data");
    //        toolStripFakeData.CheckOnClick = true;
            
    //        toolStripRBI5.Click +=new EventHandler(toolStripRBI5_Click);
    //        toolStripRBI15.Click +=new EventHandler(toolStripRBI15_Click);
    //        toolStripRBI30.Click +=new EventHandler(toolStripRBI30_Click);
    //        toolStripGBI5.Click +=new EventHandler(toolStripGBI5_Click);
    //        toolStripGBI15.Click +=new EventHandler(toolStripGBI15_Click);
    //        toolStripGBI30.Click +=new EventHandler(toolStripGBI30_Click);
    //        toolStripFakeData.Click +=new EventHandler(toolStripFakeData_Click);
           
    //        ToolStripMenuItem mainMenuItem = _mainProgram.AddToToolsMenu("TIQ RBI/GBI", null);

    //        mainMenuItem.DropDownItems.Add(toolStripFakeData);
    //        mainMenuItem.DropDownItems.Add(toolStripRBI5);
    //        mainMenuItem.DropDownItems.Add(toolStripRBI15);
    //        mainMenuItem.DropDownItems.Add(toolStripRBI30);
    //        mainMenuItem.DropDownItems.Add(toolStripGBI5);
    //        mainMenuItem.DropDownItems.Add(toolStripGBI15);
    //        mainMenuItem.DropDownItems.Add(toolStripGBI30);
    //    }
    //    void toolStripRBI5_Click(object sender, EventArgs e)
    //    {
    //        CustomEoC eoc = new CustomEoC(_mainProgram.ConnectionMaster);
    //        eoc.Category = "tipro-RBI5";
    //        eoc.Show();
    //    }
    //    void toolStripRBI15_Click(object sender, EventArgs e)
    //    {
    //       CustomEoC eoc =  new CustomEoC(_mainProgram.ConnectionMaster);
    //       eoc.Category = "tipro-RBI15";
    //       eoc.Show();
    //    }
    //    void toolStripRBI30_Click(object sender, EventArgs e)
    //    {
    //        CustomEoC eoc = new CustomEoC(_mainProgram.ConnectionMaster);
    //        eoc.Category = "tipro-RBI30";
    //        eoc.Show();
    //    }
    //    void toolStripGBI5_Click(object sender, EventArgs e)
    //    {
    //        CustomEoC eoc = new CustomEoC(_mainProgram.ConnectionMaster);
    //        eoc.Category = "tipro-GBI5";
    //        eoc.Show();
    //    }
    //    void toolStripGBI15_Click(object sender, EventArgs e)
    //    {
    //        CustomEoC eoc = new CustomEoC(_mainProgram.ConnectionMaster);
    //        eoc.Category = "tipro-GBI15";
    //        eoc.Show();
    //    }
    //    void toolStripGBI30_Click(object sender, EventArgs e)
    //    {
    //        CustomEoC eoc = new CustomEoC(_mainProgram.ConnectionMaster);
    //        eoc.Category = "tipro-GBI30";
    //        eoc.Show();
    //    }
    //    void toolStripFakeData_Click(object sender, EventArgs e)
    //    {
    //        if (toolStripFakeData.Checked)
    //        {
    //            TIQUtilities.StopFakeData();
    //            TIQUtilities.StartFakeData(_mainProgram.ConnectionMaster);
    //        }
    //        else
    //        {
    //            TIQUtilities.StopFakeData();
    //        }
    //    }
    //}



    public class ConfigWindowChooserExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new ConfigWindowChooserExtension((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private ConfigWindowChooserExtension(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        private ToolStripMenuItem TraditionalMenuItem;
      //  private ToolStripMenuItem SmallMenuItem;
        private ToolStripMenuItem VerboseMenuItem;

        public void MainInit()
        {
            ToolStripMenuItem mainMenuItem = _mainProgram.AddToToolsMenu("Choose Config Window", null);
            TraditionalMenuItem = new ToolStripMenuItem("Traditional");
         //   SmallMenuItem = new ToolStripMenuItem("Small");
            VerboseMenuItem = new ToolStripMenuItem("Verbose");
            mainMenuItem.DropDownItems.Add(TraditionalMenuItem);
          //  mainMenuItem.DropDownItems.Add(SmallMenuItem);
            mainMenuItem.DropDownItems.Add(VerboseMenuItem);
            TraditionalMenuItem.Checked = true;
            TraditionalMenuItem.Click += new EventHandler(TraditionalMenuItem_Click);
           // SmallMenuItem.Click += new EventHandler(SmallMenuItem_Click);
            VerboseMenuItem.Click += new EventHandler(VerboseMenuItem_Click);
        }

        void VerboseMenuItem_Click(object sender, EventArgs e)
        {
            VerboseMenuItem.Checked = true;
            //SmallMenuItem.Checked = false;
            TraditionalMenuItem.Checked = false;
            ConfigWindowWrapper.DefaultFactory = VerboseConfigWindowWrapper.Factory;
        }

        //void SmallMenuItem_Click(object sender, EventArgs e)
        //{
        //    SmallMenuItem.Checked = true;
        //    TraditionalMenuItem.Checked = false;
        //    VerboseMenuItem.Checked = false;
        //    ConfigWindowWrapper.DefaultFactory = SmallConfigWindowWrapper.Factory;
        //}

        void TraditionalMenuItem_Click(object sender, EventArgs e)
        {
            TraditionalMenuItem.Checked = true;
           // SmallMenuItem.Checked = false;
            VerboseMenuItem.Checked = false;
            ConfigWindowWrapper.DefaultFactory = TraditionalConfigWindowWrapper.Factory;
        }
    }

    public class RowDataExtensionTest : IMainInit, IRowDataExtension
    {
        public bool NewPowerfulFunction() { return true; }
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new RowDataExtensionTest((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private RowDataExtensionTest(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        private bool _rowDataExtensionEnabled = false;
        private bool _rowDataExtensionLoggingEnabled = false;

        public void MainInit()
        {
            ToolStripMenuItem menuItem = null;  // This line is required to keep the compiler happy.
            menuItem = _mainProgram.AddToToolsMenu("Enable RowData Test Extension", delegate
            {
                _rowDataExtensionEnabled = menuItem.Checked;
            });
            menuItem.CheckOnClick = true;
            menuItem.Checked = _rowDataExtensionEnabled;

            ToolStripMenuItem loggingMenuItem = null;  // This line is required to keep the compiler happy.
            loggingMenuItem = _mainProgram.AddToToolsMenu("Enable RowData Extension Logging", delegate
            {
                _rowDataExtensionLoggingEnabled = loggingMenuItem.Checked;
            });
            loggingMenuItem.CheckOnClick = true;
            loggingMenuItem.Checked = _rowDataExtensionLoggingEnabled;

        }

        private class RowDataHostMenuItem: ToolStripMenuItem
        {
            public object RowDataHost { get; set; }
            public RowDataHostMenuItem() { }
        }

        public ToolStripMenuItem GetMenuItem(object host)
        {
            if (!_rowDataExtensionEnabled)
                return null;
            RowDataHostMenuItem menuItem = new RowDataHostMenuItem();
            menuItem.Text = "RowData Logging Enabled";
            menuItem.CheckOnClick = true;
            menuItem.RowDataHost = host;
            menuItem.Click += menuItem_Click;
            return menuItem;
        }

        void menuItem_Click(object sender, EventArgs e)
        {
            RowDataHostMenuItem menuItem = sender as RowDataHostMenuItem;
            if (null != menuItem)
            {
                if (_enabledForHost.ContainsKey(menuItem.RowDataHost))
                    _enabledForHost[menuItem.RowDataHost] = menuItem.Checked;
                else
                    _enabledForHost.Add(menuItem.RowDataHost, menuItem.Checked);
            }
        }

        private Dictionary<object, bool> _enabledForHost = new Dictionary<object, bool>();

        public IList<ColumnInfo> HandleColumnInfo(object host, IList<ColumnInfo> columns)
        {
            IList<ColumnInfo> newColumns = new List<ColumnInfo>(columns);
            if (_enabledForHost.ContainsKey(host) && _enabledForHost[host])
            {
                ColumnInfo delayColumn = new ColumnInfo();
                delayColumn.Format = "1";
                delayColumn.InternalCode = "Delay";
                delayColumn.WireName = "Delay";
                delayColumn.SizeHint = "XXX.X";
                delayColumn.Description = "Delay (s)";
                delayColumn.TextHeader = true;
                newColumns.Add(delayColumn);
            }
            return newColumns;
        }
        public List<RowData> HandleRowData(object host, string windowName, IList<ColumnInfo> columns, List<RowData> rowDatas)
        {
            if (_enabledForHost.ContainsKey(host) && _enabledForHost[host])
            {
                foreach (RowData rowData in rowDatas)
                {
                    if (!rowData.Data.ContainsKey("Delay"))
                    {
                        if (rowData.Data.ContainsKey(CommonAlertFields.HISTORICAL) && rowData.GetAsInt(CommonAlertFields.HISTORICAL, 0) == 1)
                            rowData.Data.Add("Delay", "N/A");
                        else
                        {
                            DateTime? alertTime = rowData.GetTime();
                            if (alertTime.HasValue)
                            {
                                double delay = (DateTime.Now - alertTime.Value).TotalMilliseconds;
                                rowData.Data.Add("Delay", (delay / 1000).ToString());
                                LogRowData(windowName, columns, rowData);
                            }
                            else
                                rowData.Data.Add("Delay", "Time Format Error");
                        }
                    }
                }
            }
            return rowDatas;
        }

        public void SaveToLayout(object parent, XmlNode description) { }

        public void RestoreFromLayout(object parent, XmlNode description) { }

        public string GetId()
        {
            return "DELAY_LOGGER";
        }

        private string GetCsvHeader(IList<ColumnInfo> columns)
        {
            string csv = "";
            string comma = "";
            foreach (ColumnInfo column in columns)
            {
                string columnName = column.Description;
                csv += comma + "\"" + columnName + "\"";
                comma = ",";
            }
            return csv;
        }

        private string GetCsv(RowData rowData, IList<ColumnInfo> columns)
        {
            string csv = "";
            string comma = "";
            foreach (ColumnInfo column in columns)
            {
                string columnId = column.WireName;
                string columnValue = rowData.GetAsString(columnId, "");
                csv += comma + "\"" + columnValue + "\"";
                comma = ",";
            }
            return csv;
        }

        private void LogRowData(string windowName, IList<ColumnInfo> columns, RowData rowData)
        {
            try
            {
                string logFile = LogFilePath(windowName);
                if (!System.IO.File.Exists(logFile))
                {
                    string csvHeader = GetCsvHeader(columns);
                    using (System.IO.FileStream fileStream = new System.IO.FileStream(logFile, System.IO.FileMode.Append, System.IO.FileAccess.Write, System.IO.FileShare.None))
                    {
                        using (System.IO.StreamWriter streamWriter = new System.IO.StreamWriter(fileStream))
                        {
                            streamWriter.WriteLine("TimeStamp," + csvHeader);
                        }
                    }
                }

                using (System.IO.FileStream fileStream = new System.IO.FileStream(logFile, System.IO.FileMode.Append, System.IO.FileAccess.Write, System.IO.FileShare.None))
                {
                    using (System.IO.StreamWriter streamWriter = new System.IO.StreamWriter(fileStream))
                    {
                        streamWriter.WriteLine(GetLogTimestamp() + "," + GetCsv(rowData, columns));
                    }
                }
            }
            catch (Exception e)
            {
                string debugView = e.ToString();
            }
        }

        private static string GetLogTimestamp()
        {
            DateTime now = DateTime.Now;
            return now.ToString("HH:mm:ss.ffff");
        }

        private string LogFilePath(string windowName)
        {
            string cleanWindowName = CleanFileName(windowName);
            string logFilePath = GuiEnvironment.DataDirectory + "\\delays." + cleanWindowName + "." + DateTime.Now.ToString("yyyyMMdd") + ".csv";
            return logFilePath;
        }

        private static string CleanFileName(string fileName)
        {
            return System.IO.Path.GetInvalidFileNameChars().Aggregate(fileName, (current, c) => current.Replace(c.ToString(), string.Empty));
        }
    }

    public class MultiChannelMode : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new MultiChannelMode((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private MultiChannelMode(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            var layoutManager = LayoutManager.Instance();
            ToolStripMenuItem menuItem = null;  // This line is required to keep the compiler happy.
            menuItem = _mainProgram.AddToToolsMenu("Multi-Channel Mode Enabled", delegate
            {
                bool state = menuItem.Checked;
                layoutManager.MultiChannelEnabled = menuItem.Checked;
            });
            menuItem.CheckOnClick = true;
            menuItem.Checked = layoutManager.MultiChannelEnabled;
            //menuItem.Image = OddsMakerResults.WindowIconCache.MenuImage;
        }
    }

    public class MonsterOddsMakerExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new MonsterOddsMakerExtension((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private MonsterOddsMakerExtension(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            ToolStripMenuItem menuItem = null;  // This line is required to keep the compiler happy.
            menuItem = _mainProgram.AddToToolsMenu("Request lots of OddsMaker™ results", delegate
            {
                bool state = menuItem.Checked;
                OddsMakerManager.LotsOfResults = menuItem.Checked;
            });
            menuItem.CheckOnClick = true;
            menuItem.Checked = OddsMakerManager.LotsOfResults;
            //menuItem.Image = OddsMakerResults.WindowIconCache.MenuImage;
        }
    }

    public class GenerateTestException : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new GenerateTestException((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private GenerateTestException(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Generate Test Exception", delegate
            {
                throw new Exception("Test exception from Generate Test Exception Class");
            });
        }
    }

    public class GenerateThreadException : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new GenerateThreadException((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private GenerateThreadException(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Generate Thread Exception", delegate
            {
                new Thread(new ThreadStart(delegate()
                {
                    throw new Exception("Test exception from Generate Thread Exception Class");
                })).Start();
            });
        }
    }

    public class TestLimitedMode : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new TestLimitedMode((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private TestLimitedMode(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            ToolStripMenuItem menuItem = null;  // This line is required to keep the compiler happy.
            menuItem = _mainProgram.AddToToolsMenu("Limited Mode", delegate
            {
                List<ISupportLimitedMode> limitedModeForms = Application.OpenForms.OfType<ISupportLimitedMode>().ToList();
                foreach (ISupportLimitedMode limitedModeForm in limitedModeForms)
                {
                    limitedModeForm.LimitedMode = menuItem.Checked;
                }
                GuiEnvironment.LimitedMode = menuItem.Checked;
            });
            menuItem.CheckOnClick = true;
        }
    }

    public class ShowDevTools : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new ShowDevTools((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private ShowDevTools(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            ToolStripMenuItem menuItem = null;  // This line is required to keep the compiler happy.
            menuItem = _mainProgram.AddToToolsMenu("Show Dev Tools", delegate
            {
                List<ISupportLimitedMode> limitedModeForms = Application.OpenForms.OfType<ISupportLimitedMode>().ToList();
                foreach (ISupportLimitedMode limitedModeForm in limitedModeForms)
                {
                    limitedModeForm.LimitedMode = menuItem.Checked;
                }
                GuiEnvironment.ShowDevTools = menuItem.Checked;
            });
            menuItem.CheckOnClick = true;
        }
    }

    public class WelcomeScreenExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new WelcomeScreenExtension((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private WelcomeScreenExtension(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Welcome Screen...", ShowNow);
        }

        private void ShowNow()
        {   // If one already exists, reuse it.  Otherwise, show a new one.
            foreach (Form form in Application.OpenForms.Cast<Form>().Where(x => !x.IsDisposed).ToList())
            {
                WelcomeScreen welcomeScreen = form as WelcomeScreen;
                if (null != welcomeScreen && welcomeScreen.Text == "WelcomeScreen")
                {
                    welcomeScreen.Visible = true;
                    welcomeScreen.WindowState = FormWindowState.Normal;
                    welcomeScreen.BringToFront();
                    return;
                }
            }
            WelcomeScreen welcomeScreenForm = new WelcomeScreen(true);
            welcomeScreenForm.UseTabInterface = true;
            welcomeScreenForm.Show();
        }
    }
    //public class SingleStockWindowExtension : IMainInit
    //{
    //    public static IList<Object> GetExtensions(Object mainProgram)
    //    {
    //        List<Object> result = new List<object>(1);
    //        result.Add(new SingleStockWindowExtension((IMainProgram)mainProgram));
    //        return result;
    //    }

    //    private readonly IMainProgram _mainProgram;

    //    private SingleStockWindowExtension(IMainProgram mainProgram)
    //    {
    //        _mainProgram = mainProgram;
    //    }

    //    public void MainInit()
    //    {
    //        _mainProgram.AddToToolsMenu("Single Stock Window...", ShowNow);
    //    }

    //    private void ShowNow()
    //    {   // If one already exists, reuse it.  Otherwise, show a new one.
    //        foreach (Form form in Application.OpenForms.Cast<Form>().ToList())
    //        {
    //            SingleStockWindow singleStockWindow = form as SingleStockWindow;
    //            if (null != singleStockWindow)
    //            {
    //                singleStockWindow.Visible = true;
    //                singleStockWindow.WindowState = FormWindowState.Normal;
    //                return;
    //            }
    //        }
    //        string singleStockConfig = "form=1&show0=D_Symbol&show1=UpJan1P&show2=R60M&show3=U20DP&show4=RD&show5=MCap&show6=R5D&show7=ShortG&show8=RY&show9=SFloat&show10=Cash&show11=EPS&show12=Debt&show13=EarningD&show14=Revenue&show15=STH&show16=QRevG&show17=STP&show18=&col_ver=1&sort=MaxRV&X_NYSE=on&X_ARCA=on&X_AMEX=on&XN=on&X_OTC=on&X_PINK=on&X_CAT=on&X_CAV=on&XX=on&EntireUniverse=3&SingleSymbol=SPY&WN=SPY";
    //        SingleStockWindow singleStockWindowForm = new SingleStockWindow(_mainProgram.ConnectionMaster,singleStockConfig);
    //        singleStockWindowForm.Show();
    //    }
    //}

    /*
    public class CloudExtensions : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new CloudExtensions((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private CloudExtensions(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            ToolStripMenuItem menuItem = _mainProgram.AddToToolsMenu("Save to Cloud...", delegate
            {
                SaveToCloud.DoIt(_mainProgram.ConnectionMaster.SendManager);
            });
            menuItem.Image = SaveToCloud.WindowIconCache.MenuImage;
            menuItem = _mainProgram.AddToToolsMenu("Load from Cloud...", delegate
            {
                LoadFromCloud.DoIt(_mainProgram.ConnectionMaster.SendManager);
            });
            menuItem.Image = LoadFromCloud.WindowIconCache.MenuImage;
        }
    }
     */

    //public class EarningsDateExtension : IMainInit
    //{
    //    public static IList<Object> GetExtensions(Object mainProgram)
    //    {
    //        List<Object> result = new List<object>(1);
    //        result.Add(new EarningsDateExtension());
    //        return result;
    //    }

    //    public void MainInit()
    //    {
    //        ConfigDemo.Add("EarningD", delegate(IContainer container) { return new ConfigDemoEarningsDate(container); });
    //    }
    //}

    /*
    public class UpFromTheCloseDollarExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new UpFromTheCloseDollarExtension());
            return result;
        }

        public void MainInit()
        {
            ConfigDemo.Add("FCD", delegate(IContainer container) { return new ConfigDemoUpFromTheCloseDollar(container); });
        }
    }
    public class UpFromTheCloseBarsExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new UpFromTheCloseBarsExtension());
            return result;
        }

        public void MainInit()
        {
            ConfigDemo.Add("FCR", delegate(IContainer container) { return new ConfigDemoUpFromTheCloseBars(container); });
        }
    }
    public class BarsAboveSMAExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new BarsAboveSMAExtension());
            return result;
        }

        public void MainInit()
        {
            ConfigDemo.Add("MA200R", delegate(IContainer container) { return new ConfigDemoBarsAboveSMA(container,200); });
            ConfigDemo.Add("MA50R", delegate(IContainer container) { return new ConfigDemoBarsAboveSMA(container, 50); });
            ConfigDemo.Add("MA20R", delegate(IContainer container) { return new ConfigDemoBarsAboveSMA(container, 20); });
            ConfigDemo.Add("MA8R", delegate(IContainer container) { return new ConfigDemoBarsAboveSMA(container, 8); });
        }
    }
    public class UpFromTheOpenDollarExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new UpFromTheOpenDollarExtension());
            return result;
        }

        public void MainInit()
        {
            ConfigDemo.Add("FOD", delegate(IContainer container) { return new ConfigDemoUpFromTheOpenDollar(container); });
        }
    }
    public class UpFromTheOpenPercentExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new UpFromTheOpenPercentExtension());
            return result;
        }

        public void MainInit()
        {
            ConfigDemo.Add("FOP", delegate(IContainer container) { return new ConfigDemoUpFromTheOpenPercent(container); });
        }
    }
    public class UpFromTheOpenBarsExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new UpFromTheOpenBarsExtension());
            return result;
        }

        public void MainInit()
        {
            ConfigDemo.Add("FOR", delegate(IContainer container) { return new ConfigDemoUpFromTheOpenBars(container); });
        }
    }
    public class UpFromTheOpenATRExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new UpFromTheOpenATRExtension());
            return result;
        }

        public void MainInit()
        {
            ConfigDemo.Add("FOW", delegate(IContainer container) { return new 
                ConfigDemoUpFromTheOpenATR(container); });
        }
    }
    */
    public class DailyConsolidationExtension : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new DailyConsolidationExtension());
            return result;
        }

        public void MainInit()
        {
            //ConfigDemo.Add("ConDays", delegate(IContainer container) { return new ConfigDemoConsolidationDays(container); });
            //ConfigDemo.Add("RCon", delegate(IContainer container) { return new ConfigDemoDailyRanges(container); });
            //ConfigDemo.Add("R5D", delegate(IContainer container) { return new ConfigDemoDailyRanges(container, 5); });
            //ConfigDemo.Add("R10D", delegate(IContainer container) { return new ConfigDemoDailyRanges(container, 10); });
            //ConfigDemo.Add("R20D", delegate(IContainer container) { return new ConfigDemoDailyRanges(container, 20); });
            
        }
    }

    public class ServerSubscriptionTesterWindow : IMainInit
    {
        public static IList<Object> GetExtensions(Object mainProgram)
        {
            List<Object> result = new List<object>(1);
            result.Add(new ServerSubscriptionTesterWindow((IMainProgram)mainProgram));
            return result;
        }

        private readonly IMainProgram _mainProgram;

        private ServerSubscriptionTesterWindow(IMainProgram mainProgram)
        {
            _mainProgram = mainProgram;
        }

        public void MainInit()
        {
            _mainProgram.AddToToolsMenu("Server Command and Subscription Tester", delegate
            {
                new ServerSubscriptionTester().Show();
            });
        }
    }
}