using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.Xml;
using TradeIdeas.TIProData;
using TradeIdeas.TIProData.Interfaces;
using TradeIdeas.TIProGUI.AI;
using TradeIdeas.TIProGUI;
using TradeIdeas.ServerConnection;
using TradeIdeas.XML;
using TradeIdeas.MiscSupport;

namespace TIProDevExtension
{
    public partial class ServerSubscriptionTester : Form
    {
        private readonly IConnectionMaster _connectionMaster;
        private TalkWithServer.CancelToken _cancelToken;

        /// <summary>
        /// Provides access to the AiData object for each AiSegment.
        /// </summary>
        private Dictionary<AiSegment, IAiData> _aiSegmentData = new Dictionary<AiSegment, IAiData>();
        
        /// <summary>
        /// The main AI data manager object.  All AI data for all segments is managed by this object.
        /// </summary>
        private AiDataManager _aiDataManager = null;

        /// <summary>
        /// The overarching AiData object that requests segments.  New AiData objects are spawned for each segment.
        /// </summary>
        private IAiData _aiDataMain = null;

        private Dictionary<string, AIStrategy> _strategyCodes = new Dictionary<string, AIStrategy>();
        private List<AIStrategy> _strategies = new List<AIStrategy>();
        private string _segmentCode = "all";
        private List<AiSegment> _segments = new List<AiSegment>();

        private AiLongTermManager _aiLongTermManager = null;
        private IAiLongTermData _aiLongTermDataMain = null;
        private string _serverCommand = GuiEnvironment.GlobalSettings.Node("AI_LONG_TERM").Node("AI_LONG_TERM_COMMAND").Property("VALUE", "ai_long_term");

        public ServerSubscriptionTester()
        {
            InitializeComponent();
            _connectionMaster = ConnectionMaster.First;
            cboResponseParameterType.SelectedIndex = 0;
        }

        private void RetrieveAiSegments()
        {
            _aiDataManager = AiDataManager.Instance();
            _aiDataMain = _aiDataManager.GetAiData("main");
            _aiDataMain.AiSegmentsReceived -= AiData_AiSegmentsReceived;
            _aiDataMain.AiSegmentsReceived += AiData_AiSegmentsReceived;
            _aiDataMain.RequestSegments();
        }

        private void AiData_AiSegmentsReceived(List<AiSegment> segments)
        {
            ClearAiConnections();
            _aiSegmentData.Clear();
            _strategies.Clear();
            foreach (AiSegment aiSegment in segments)
            {
                if (_segmentCode == "all" || aiSegment.Code == _segmentCode)
                {
                    IAiData aiData = _aiDataManager.GetAiData(aiSegment.Code);
                    aiData.AiStrategiesReceived -= AiData_AiStrategiesReceived;
                    aiData.AiStrategiesReceived += AiData_AiStrategiesReceived;
                    //Debug.WriteLine("[AiSegmentReceived] Requesting strategies for " + aiSegment.Code);
                    aiData.RequestStrategies(aiSegment.Code);
                    aiData.AiUpdateReceived -= AiData_AiUpdateReceived;
                    aiData.AiUpdateReceived += AiData_AiUpdateReceived;
                    aiData.AiRefreshReceived -= AiData_AiRefreshReceived;
                    aiData.AiRefreshReceived += AiData_AiRefreshReceived;
                    aiData.SubscribeToUpdates(aiSegment.Code);
                    _aiSegmentData.Add(aiSegment, aiData);
                }
            }
            _segments = segments;
        }

        /// <summary>
        /// Unsubscribe to all segment updates and clear the _aiSegmentData dictionary.
        /// </summary>
        private void ClearAiConnections()
        {
            //Debug.WriteLine("Called ClearAiConnections");
            if (_aiSegmentData.Keys.Count > 0)
            {
                foreach (AiSegment aiSegment in _aiSegmentData.Keys)
                {
                    IAiData aiData = _aiSegmentData[aiSegment];
                    aiData.UnsubscribeToUpdates();
                    aiData.AiSegmentsReceived -= AiData_AiSegmentsReceived;
                    aiData.AiStrategiesReceived -= AiData_AiStrategiesReceived;
                    aiData.AiUpdateReceived -= AiData_AiUpdateReceived;
                    aiData.AiRefreshReceived -= AiData_AiRefreshReceived;
                    aiData = null;
                }
                _aiSegmentData.Clear();
            }
        }

        private void AiData_AiStrategiesReceived(IAiData sender, string xml, string segment, string windowId)
        {
            int id = 0;
            List<AIStrategy> strategies = AiUtils.GetStrategiesFromResponse(xml, segment, _segments);
            AddServerResponse("AI Strategy:\r\n" + xml);
            foreach (AIStrategy strategy in strategies)
            {
                string strategyCode = id + "-" + segment;
                AddStrategy(strategy, strategyCode);
                id++;
            }
        }

        private void AddStrategy(AIStrategy strategy, string strategyCode)
        {
            _strategyCodes[strategyCode] = strategy;
            _strategies.Add(strategy);
        }

        private void AiData_AiUpdateReceived(IAiData sender, string csv, int epoch, string segment, string windowId)
        {
            //Debug.WriteLine("Got AiUpdateReceived from segment " + segment + " windowId " + windowId);
            if (segment != "" && segment != _segmentCode && _segmentCode != "all")
                return;

            AddServerResponse("Strategy Trades:\r\n" + csv);
        }

        private void AiData_AiRefreshReceived()
        {
            //Debug.WriteLine("[StrategyTradesForm AiRefreshReceived] Calling RefreshAiData after receiving refresh code from the server. Title=" + Text);
            //GuiEnvironment.LogMessage("[StrategyTradesForm AiRefreshReceived] Calling RefreshAiData after receiving refresh code from the server. Title=" + Text);
            RefreshAiData();
        }

        private void RefreshAiData()
        {
            try
            {
                //Debug.WriteLine("[StrategyTradesForm RefreshAiData] Calling RefreshAiData after receiving refresh code from the server. Title=" + Text);
                ClearAiConnections();
                RetrieveAiSegments();
            }
            catch// (Exception e)
            {
                //GuiEnvironment.LogMessage("[StrategyTradesForm RefreshAiData] Got exception in window " + Text + ": " + e.Message + ", st=" + e.StackTrace);
            }
        }

        private void AddServerResponse(string response)
        {
            this.InvokeIfRequired(delegate
            {
                txtServerResponses.AppendText(response + "\r\n\r\n");
            });
        }

        private void ServerSubscriptionTester_FormClosing(object sender, FormClosingEventArgs e)
        {
            ClearAiConnections();
            CancelPreviousListenerCallback();
            UnsubscribeAiLtUpdates();
        }

        private Dictionary<string, byte[]> CreateMessageToSend()
        {
            Dictionary<string, byte[]> messageToSend = null;

            if (!string.IsNullOrEmpty(txtCommand.Text) && !string.IsNullOrEmpty(txtSubCommand.Text))
            {
                // Create base message with command and subcommand.
                List<string> message = new List<string>
                {
                    "command", txtCommand.Text,
                    "subcommand", txtSubCommand.Text
                };

                // Add parameters if any.
                if (lstParameters.Items.Count > 0)
                {
                    foreach (ListViewItem listViewItem in lstParameters.Items)
                    {
                        message.Add(listViewItem.Text);
                        message.Add(listViewItem.SubItems[1].Text);
                    }
                }

                messageToSend = TalkWithServer.CreateMessage(message.ToArray<object>());
            }

            return messageToSend;
        }

        private void SendMessageToServer()
        {
            if (!string.IsNullOrEmpty(txtCommand.Text) && !string.IsNullOrEmpty(txtSubCommand.Text))
            {
                Dictionary<string, byte[]> messageToSend = CreateMessageToSend();
                if (messageToSend != null)
                {
                    CancelPreviousListenerCallback();
                    _cancelToken = new TalkWithServer.CancelToken();
                    _connectionMaster.SendManager.SendMessage(messageToSend, ServerResponseReceived, chkStreaming.Checked, cancelToken: _cancelToken);
                }
            }
            else
            {
                MessageBox.Show("Enter a command and subcommand.");
            }
        }

        private void ServerResponseReceived(byte[] body, object clientId)
        {
            // if we get disconnected from the server, send the request again which will allow a seamless experience when reconnected
            if (null == body)
            {
                SendMessageToServer();
                return;
            }
            string response = System.Text.Encoding.UTF8.GetString(body);
            // Show response as text.
            AddServerResponse(response);

            // Parse XML and show results.
            XmlNode message = XmlHelper.Get(body).Node(0);
            if (message != null)
            {
                this.InvokeIfRequired(delegate
                {

                    foreach (ListViewItem listViewItem in lstResponseParameters.Items)
                    {
                        string xmlValue = "";
                        string parameter = listViewItem.Text;
                        string type = listViewItem.SubItems[1].Text;
                        try
                        {
                            if (type == "string")
                                xmlValue = message.Property(parameter, "");
                            else if (type == "int")
                                xmlValue = message.Property(parameter, -1).ToString();
                            else if (type == "double")
                                xmlValue = message.Property(parameter, 0.0).ToString();
                            else if (type == "bool")
                                xmlValue = message.Property(parameter, false).ToString();
                            else if (type == "DateTime")
                                xmlValue = ServerFormats.FromTimeT(message.Property(parameter, 0)).ToString();
                        }
                        catch (Exception ex)
                        {
                            xmlValue = "ERROR: " + ex.Message;
                        }

                        AddServerResponse($"{parameter} as {type}: {xmlValue}");
                    }
                });
            }
        }

        private void CancelPreviousListenerCallback()
        {
            if (null != _cancelToken)
            {
                _connectionMaster.SendManager.CancelMessage(_cancelToken);
                _cancelToken = null;
            }
        }

        private void btnSendCommand_Click(object sender, EventArgs e)
        {
            SendMessageToServer();
        }

        private void btnCancelRequests_Click(object sender, EventArgs e)
        {
            CancelPreviousListenerCallback();
        }

        private void btnAddParameter_Click(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(txtParameterName.Text) && !string.IsNullOrEmpty(txtParameterValue.Text))
            {
                ListViewItem listViewItem = new ListViewItem() { Text = txtParameterName.Text };
                listViewItem.SubItems.Add(new ListViewItem.ListViewSubItem() { Text = txtParameterValue.Text });
                lstParameters.Items.Add(listViewItem);
            }
            else
            {
                MessageBox.Show("Enter a command parameter and value.");
            }
        }

        private void btnDeleteParameters_Click(object sender, EventArgs e)
        {
            List<ListViewItem> itemsToDelete = new List<ListViewItem>();
            foreach (ListViewItem listViewItem in lstParameters.SelectedItems)
            {
                itemsToDelete.Add(listViewItem);
            }
            foreach (ListViewItem listViewItem in itemsToDelete)
            {
                lstParameters.Items.Remove(listViewItem);
            }
        }

        private void btnClearServerResponses_Click(object sender, EventArgs e)
        {
            txtServerResponses.Text = "";
        }

        private void btnSubscribeAIData_Click(object sender, EventArgs e)
        {
            RetrieveAiSegments();
        }

        private void btnUnsubscribeAIData_Click(object sender, EventArgs e)
        {
            ClearAiConnections();
        }

        private void btnChartHistoricalAITrades_Click(object sender, EventArgs e)
        {
            txtCommand.Text = "ai_feed_command";
            txtSubCommand.Text = "ai_trade_history";
            lstParameters.Items.Clear();
            txtParameterName.Text = "symbol";
            txtParameterValue.Text = "AAPL";
        }

        private void btnSubscribeAILtData_Click(object sender, EventArgs e)
        {
            SubscribeAiLtUpdates();
        }

        private void btnUnsubscribeAiLtData_Click(object sender, EventArgs e)
        {
            UnsubscribeAiLtUpdates();
        }

        private void SubscribeAiLtUpdates()
        {
            _aiLongTermManager = AiLongTermManager.Instance();
            _aiLongTermDataMain = _aiLongTermManager.GetAiLongTermData(_serverCommand);
            _aiLongTermDataMain.AiLongTermUpdateReceived -= AiLongTermData_AiUpdateReceived;
            _aiLongTermDataMain.AiLongTermUpdateReceived += AiLongTermData_AiUpdateReceived;
            _aiLongTermDataMain.SubscribeToUpdates();
        }

        private void UnsubscribeAiLtUpdates()
        {
            if (_aiLongTermDataMain != null)
            {
                _aiLongTermDataMain.AiLongTermUpdateReceived -= AiLongTermData_AiUpdateReceived;
                _aiLongTermDataMain.UnsubscribeToUpdates();
            }
        }

        private void AiLongTermData_AiUpdateReceived(IAiLongTermData sender, string csv, string windowId)
        {
            AddServerResponse("Long-Term Strategy Trades:\r\n" + csv);
        }

        private void btnAddResponseParameter_Click(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(txtResponseParameterName.Text) && cboResponseParameterType.SelectedItem != null)
            {
                ListViewItem listViewItem = new ListViewItem() { Text = txtResponseParameterName.Text };
                listViewItem.SubItems.Add(new ListViewItem.ListViewSubItem() { Text = cboResponseParameterType.SelectedItem.ToString() });
                lstResponseParameters.Items.Add(listViewItem);
            }
            else
            {
                MessageBox.Show("Enter a response parameter and type.");
            }
        }

        private void btnDeleteResponseParameters_Click(object sender, EventArgs e)
        {
            List<ListViewItem> itemsToDelete = new List<ListViewItem>();
            foreach (ListViewItem listViewItem in lstResponseParameters.SelectedItems)
            {
                itemsToDelete.Add(listViewItem);
            }
            foreach (ListViewItem listViewItem in itemsToDelete)
            {
                lstResponseParameters.Items.Remove(listViewItem);
            }
        }
    }
}