using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using System.Windows.Forms.DataVisualization.Charting;
using System.Xml;
using TradeIdeas.TIProData;
using TradeIdeas.TIProData.Interfaces;
using TradeIdeas.XML;

namespace TradeIdeas.TIProGUI
{
    public partial class MarketSummaryHistogram : Form
    {
        private IConnectionMaster _connectionMaster;

        public MarketSummaryHistogram(IConnectionMaster connectionMaster)
        {
            _connectionMaster = connectionMaster;

            InitializeComponent();

            if (!IsHandleCreated)
                CreateHandle();

            foreach (Universe universe in Universe.VALUES)
                universeComboBox.Items.Add(universe);
            universeComboBox.SelectedIndex = 0;
            
            // Force the events to fire now.
            groupComboBox.SelectedIndex = 0;
        }

        private void UpdateIcon()
        {
            if (null == _option)
                filterIconPictureBox.Image = null;
            else
                filterIconPictureBox.Image = _connectionMaster.ImageCacheManager.GetFilter("Min" + _option.FilterCode);
        }

        private MarketSummaryRequest _outstandingRequest;
        private Option _option;
        private string _universe;

        private void RequestData()
        {
            _outstandingRequest = null;
            UpdateIcon();
            if ((null == _option) || (null == _universe))
                return;
            string configString = _universe + _option.Settings + "&col_ver=1";
            if (configStringTextBox.Text != "")
                configString = configStringTextBox.Text;
            _outstandingRequest = new MarketSummaryRequest(configString, _connectionMaster.SendManager);
            _outstandingRequest.ResponseFromServer += _outstandingRequest_ResponseFromServer;
            _outstandingRequest.SendRequest();
        }

        void _outstandingRequest_ResponseFromServer(MarketSummaryRequest sender)
        {
            this.InvokeIfRequired((MethodInvoker)delegate
            {
                if (sender == _outstandingRequest)
                {
                    if (null == sender.SimpleResult)
                        // Try again.
                        RequestData();
                    else
                        ShowData(sender.SimpleResult);
                }
            });
        }

        private void ShowData(List<MarketSummaryRequest.SimpleItem> items)
        {
            chart1.Series[0].Points.Clear();
            foreach (MarketSummaryRequest.SimpleItem item in items)
            {
                DataPoint dataPoint = new DataPoint(chart1.Series[0]);
                dataPoint.YValues = new double[] { item.Y };
                dataPoint.Color = _option.GetColor(item.X);
                dataPoint.AxisLabel = item.X.ToString();
                chart1.Series[0].Points.Add(dataPoint);
            }
            chart1.Visible = true;
        }

        private struct Universe
        {
            public string Name;
            public string Code;
            public override string ToString()
            {
                return Name;
            }
            /// <summary>
            /// This should come from the server.  We should only be able to send approved values.
            /// </summary>
            static public readonly Universe[] VALUES = new Universe[] 
            { 
                new Universe{ Code = "X_NYSE=on&X_ARCA=on&X_AMEX=on&XN=on&", Name = "Major US Markets" },
                new Universe{ Code = "X_NYSE=on&X_ARCA=on&X_AMEX=on&XN=on&X_OTC=on&X_PINK=on&", Name = "All US Markets" },
                new Universe{ Code = "X_CAT=on&X_CAV=on&", Name = "Canada" },
                new Universe{ Code = "MaxPrice=0.9999&X_NYSE=on&X_ARCA=on&X_AMEX=on&XN=on&X_OTC=on&X_PINK=on&", Name = "Penny Stocks" },
                new Universe{ Code = "", Name = "Manufacturing" },
                new Universe{ Code = "", Name = "Finance" },
                new Universe{ Code = "", Name = "[Other sectors...]" } 
            };
        }

        private enum Group { InRange, AsPercent };

        private class Option
        {
            public string FilterCode { get; private set; }
            public string Settings { get; private set; }
            public Group Group { get; private set; }
            public string Time { get; private set; }
            private double _minColorValue;
            private double _maxColorValue;
            private Option(string filterCode, string settings, Group group, string time, double minColorValue, double maxColorValue)
            {
                FilterCode = filterCode;
                Settings = settings;
                Group = group;
                Time = time;
                _minColorValue = minColorValue;
                _maxColorValue = maxColorValue;
                InitGradientInfo();
            }
            private static Color OFF_THE_TOP = Color.FromArgb(0, 255, 0);
            private static Color TOP = Color.FromArgb(0, 192, 0);
            private static Color MIDDLE = Color.Black;
            private static Color BOTTOM = Color.FromArgb(255, 0, 0);
            private static Color OFF_THE_BOTTOM = Color.FromArgb(255, 128, 128);
            private static GradientInfo.ColorForPoint TOP_POINT = new GradientInfo.ColorForPoint { Above = OFF_THE_TOP, At = TOP, Below = TOP };
            private static GradientInfo.ColorForPoint MIDDLE_POINT = new GradientInfo.ColorForPoint { Above = MIDDLE, At = MIDDLE, Below = MIDDLE };
            private static GradientInfo.ColorForPoint BOTTOM_POINT = new GradientInfo.ColorForPoint { Above = BOTTOM, At = BOTTOM, Below = OFF_THE_BOTTOM };
            private GradientInfo _gradientInfo;
            private void InitGradientInfo()
            {
                _gradientInfo = new GradientInfo();
                _gradientInfo.Add(_minColorValue, BOTTOM_POINT);
                _gradientInfo.Add((_minColorValue + _maxColorValue) / 2, MIDDLE_POINT);
                _gradientInfo.Add(_maxColorValue, TOP_POINT);
            }
            public Color GetColor(double value)
            {
                return _gradientInfo.GetColor(value);
            }
            public Color GetColor(double v1, double v2)
            {
                return GetColor((v1 + v2) / 2);
            }
            public override string ToString()
            {   // This works on the simple assumption that we will be displayed in the
                // combo box listing the times.  Not a great assumption, but okay for now.
                return Time;
            }
            public static List<Option> Available()
            {   // The thought is that this would come from the server.  A big isssue is that we want
                // the settings to be appropriate so that anyone can request this is real time.  If the 
                // client can make any request he wants, we can't always give realtime data.
                List<Option> result = new List<Option>();
                //result.Add(new Option("PUp1", "", Group.AsPercent, "1 minute", 0, 100));
                result.Add(new Option("PUp2", "show1=Vol5&show0=PUp2", Group.AsPercent, "2 minutes", -0.25, 0.25));
                result.Add(new Option("PUp5", "show1=Vol5&show0=PUp5", Group.AsPercent, "5 minutes", -0.5, 0.5));
                result.Add(new Option("PUp10", "show1=Vol10&show0=PUp10", Group.AsPercent, "10 minutes", -1, 1));
                result.Add(new Option("PUp15", "show1=Vol15&show0=PUp15", Group.AsPercent, "15 minutes", -1, 1));
                result.Add(new Option("PUp30", "show1=Vol30&show0=PUp30", Group.AsPercent, "30 minutes", -1, 1));
                result.Add(new Option("PUp60", "show1=Vol30&show0=PUp60", Group.AsPercent, "1 hour", -1, 1));
                result.Add(new Option("PUp120", "show1=Vol30&show0=PUp120", Group.AsPercent, "2 hours", -1, 1));
                result.Add(new Option("FCP", "show1=Vol30&show0=FCP", Group.AsPercent, "1 day", -2, 2));
                result.Add(new Option("U5DP", "show1=Vol5D&show0=U5DP", Group.AsPercent, "1 week", -3, 3));
                result.Add(new Option("U10DP", "show1=Vol&show0=U10DP", Group.AsPercent, "2 weeks", -3, 4));
                result.Add(new Option("U20DP", "show1=Vol&show0=U20DP", Group.AsPercent, "2 month", -5, 5));
                result.Add(new Option("UYP", "show1=Vol3M&show0=UYP", Group.AsPercent, "1 year", -10, 10));
                result.Add(new Option("R5M", "show1=Vol5&show0=R5M", Group.InRange, "5 minutes", 0, 100));
                result.Add(new Option("R15M", "show1=Vol15&show0=R15M", Group.InRange, "15 minutes", 0, 100));
                result.Add(new Option("R30M", "show1=Vol30&show0=R30M", Group.InRange, "30 minutes", 0, 100));
                result.Add(new Option("R60M", "show1=Vol30&show0=R60M", Group.InRange, "1 hour", 0, 100));
                result.Add(new Option("RD", "show1=Vol30&show0=RD", Group.InRange, "1 day", 0, 100));
                result.Add(new Option("R5D", "show1=Vol5D&show0=R5D", Group.InRange, "1 week", 0, 100));
                result.Add(new Option("R10D", "show1=Vol&show0=R10D", Group.InRange, "2 week", 0, 100));
                result.Add(new Option("R20D", "show1=Vol&show0=R20D", Group.InRange, "1 month", 0, 100));
                result.Add(new Option("RY", "show1=Vol3M&show0=RY", Group.InRange, "1 year", 0, 100));
                return result;
            }
        }

        private static List<Option> OPTIONS = Option.Available();

        private void groupComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            Group group;
            switch (groupComboBox.SelectedIndex)
            {
                case 0:
                    groupComboBox.Text = "Chart";
                    group = Group.InRange;
                    break;
                case 1:
                    groupComboBox.Text = "%";
                    group = Group.AsPercent;
                    break;
                default:
                    return;
            }
            string oldTimeFrame = timeFrameComboBox.Text;
            // If we can't match what was previously selected, the first item becomes the default.
            int newTimeFrame = 0;  
            timeFrameComboBox.Items.Clear();
            foreach (Option option in OPTIONS)
            {
                if (option.Group == group)
                {
                    if (oldTimeFrame == option.Time)
                    {   // This is the same time frame the the user had previously selected.
                        // Select this again.
                        newTimeFrame = timeFrameComboBox.Items.Count;
                    }
                    timeFrameComboBox.Items.Add(option);
                }
            }
            timeFrameComboBox.SelectedIndex = newTimeFrame;
        }

        private void MarketSummaryHistogram_FormClosed(object sender, FormClosedEventArgs e)
        {
            _outstandingRequest = null;
        }

        private void timeFrameComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            _option = timeFrameComboBox.SelectedItem as Option;
            chart1.Visible = false;
            RequestData();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            RequestData();
        }

        private void universeComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            _universe = ((Universe)universeComboBox.SelectedItem).Code;
            chart1.Visible = false;
            RequestData();
        }

        private void configStringTextBox_DoubleClick(object sender, EventArgs e)
        {
            if (configStringTextBox.Text == "")
                configStringTextBox.Text = _universe + _option.Settings;
            else
            {
                chart1.Visible = false;
                RequestData();
            }
        }
    }

    class MarketSummaryRequest
    {
        private readonly ISendManager _sendManager;
        private readonly string _configString;
        public MarketSummaryRequest(string configStringString, ISendManager sendManager)
        {
            _configString = configStringString;
            _sendManager = sendManager;
        }
        public void SendRequest()
        {
            Dictionary<String, byte[]> message = ServerConnection.TalkWithServer.CreateMessage(
                "command", "market_summary_request",
                "long_form", _configString);
            _sendManager.SendMessage(message, Response);
        }
        private void Response(byte[] body, object unused)
        {
            if (null == body)
                SimpleResult = null;
            else
            {
                SimpleResult = new List<SimpleItem>();
                XmlNode debug = XmlHelper.Get(body).Node(0);
                foreach (XmlNode node in XmlHelper.Get(body).Node(0).Node("SIMPLE_REPORT").Enum())
                {
                    SimpleItem si;
                    si.X = node.Property("X", 0.0);
                    si.Y = node.Property("Y", 0.0);
                    SimpleResult.Add(si);
                }
            }
            Action<MarketSummaryRequest> callback = ResponseFromServer;
            if (null != callback)
                callback(this);
        }

        /// <summary>
        /// This is null if there was a connection error.  If we got a response from the
        /// server we always create a list.  We try our best to interpret the result from
        /// the server and do not report any errors other than the connection error.
        /// </summary>
        public List<SimpleItem> SimpleResult { get; private set; }

        /// <summary>
        /// This can come in any thread.  The argument is a pointer back to the initial
        /// object.
        /// </summary>
        public event Action<MarketSummaryRequest> ResponseFromServer;

        public struct SimpleItem
        {
            public double X;
            public double Y;
        }
    }


}