using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml;
using TradeIdeas.TIProData;
using TradeIdeas.XML;

namespace TradeIdeas.TIProGUI
{
    /// <summary>
    /// Stores all browser charts drawing tools cache.  Knows how to save to and restore from XML.
    /// </summary>
    public class BrowserChartDrawingToolsCache
    {
        public BrowserChartDrawingToolsCache() { }

        /// <summary>
        /// Adds an annotation to the cache.
        /// </summary>
        /// <param name="annotation"></param>
        /// <param name="symbol"></param>
        public void AddAnnotation(CacheableBrowserChartDrawingTools annotation, string symbol)
        {
            if (annotation == null)
            {
                return;
            }

            List<CacheableBrowserChartDrawingTools> annotations = new List<CacheableBrowserChartDrawingTools>();
            if (_annotations.ContainsKey(symbol))
                annotations = _annotations[symbol];

            var existingAnnotationIndex = annotations.FindIndex(x => x.ChartTimeframe == annotation.ChartTimeframe);
            if (existingAnnotationIndex > -1)
            {
                annotations[existingAnnotationIndex] = annotation;
            }
            else
            {
                annotations.Add(annotation);
            }

            _annotations[symbol] = annotations;
        }

        /// <summary>
        /// Gets all annotations from the cache that correspond to the symbol and timeframe.  Horizontal lines span all timeframes but all other
        /// annotation types are specific to a timeframe.
        /// </summary>
        /// <param name="symbol"></param>
        /// <param name="timeframe"></param>
        /// <returns></returns>
        public CacheableBrowserChartDrawingTools GetAnnotation(string symbol, ChartTimeframe timeframe)
        {
            List<CacheableBrowserChartDrawingTools> annotationsInScope = new List<CacheableBrowserChartDrawingTools>();
            if (_annotations.ContainsKey(symbol))
                annotationsInScope = _annotations[symbol];

            if (annotationsInScope.DoesNotHaveAny())
            {
                return new CacheableBrowserChartDrawingTools();
            }

            var foundAnnotation = annotationsInScope.FirstOrDefault(x => x.ChartTimeframe == timeframe);
            return foundAnnotation != null ? foundAnnotation : new CacheableBrowserChartDrawingTools();
        }

        /////// <summary>
        /////// Returns CacheableBrowserChartAnnotation by looking up the original id used when it was created.
        /////// </summary>
        /////// <param name="id"></param>
        /////// <param name="symbol"></param>
        /////// <returns>CacheableBrowserChartAnnotation object.</returns>
        ////public CacheableBrowserChartDrawingTools GetAnnotation(string id, string symbol)
        ////{
        ////    if (_annotations.ContainsKey(symbol))
        ////    {
        ////        List<CacheableBrowserChartDrawingTools> annotations = _annotations[symbol].Where(x => x.Id == id).ToList();
        ////        if (annotations.Count > 0)
        ////            return annotations.First();
        ////    }
        ////    return null;
        ////}

        /////// <summary>
        /////// Removes annotation from cache by first looking it up by id and symbol.  If it can't be found this does nothing.
        /////// </summary>
        /////// <param name="id"></param>
        /////// <param name="symbol"></param>
        ////public void RemoveAnnotation(string id, string symbol)
        ////{
        ////    if (_annotations.ContainsKey(symbol))
        ////    {
        ////        List<CacheableBrowserChartDrawingTools> annotations = _annotations[symbol].Where(x => x.Id == id).ToList();
        ////        if (annotations.Count > 0)
        ////        {
        ////            foreach (CacheableBrowserChartDrawingTools annotation in annotations)
        ////            {
        ////                _annotations[symbol].Remove(annotation);
        ////            }
        ////        }
        ////    }
        ////}

        /////// <summary>
        /////// Removes annotation from cache by first looking it up by symbol.  If it can't be found this does nothing.
        /////// Returns the list of Ids that has been removed
        /////// </summary>
        /////// <param name="symbol"></param>
        ////public List<string> RemoveAllAnnotation(string symbol)
        ////{
        ////    List<string> removed = new List<string>();
        ////    if (_annotations.ContainsKey(symbol))
        ////    {
        ////        List<CacheableBrowserChartDrawingTools> annotations = _annotations[symbol].ToList();

        ////        foreach (CacheableBrowserChartDrawingTools annotation in annotations)
        ////        {
        ////            removed.Add(annotation.Id);
        ////            _annotations[symbol].Remove(annotation);
        ////        }
        ////    }
        ////    return removed;
        ////}

        /// <summary>
        /// Data structure for storing all annotations.
        /// </summary>
        private Dictionary<string, List<CacheableBrowserChartDrawingTools>> _annotations = new Dictionary<string, List<CacheableBrowserChartDrawingTools>>();

        /// <summary>
        /// Caches all current annotations to XML.
        /// </summary>
        /// <returns>XML string that can be used in Restore.</returns>
        public string Save()
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.LoadXml("<BROWSER_CHARTS_ANNOTATIONS></BROWSER_CHARTS_ANNOTATIONS>");
                XmlNode annotationsNode = doc.Node("BROWSER_CHARTS_ANNOTATIONS");
                foreach (string symbol in _annotations.Keys)
                {
                    XmlNode symbolNode = annotationsNode.NewNode("SYMBOL");
                    symbolNode.SetProperty("SYMBOL", symbol);
                    foreach (CacheableBrowserChartDrawingTools annotation in _annotations[symbol])
                    {
                        annotation.Save(symbolNode);
                    }
                }
                return doc.OuterXml;
            }
            catch (Exception e)
            {
                string debugView = e.StackTrace;
                return "";
            }
        }

        /// <summary>
        /// Restores annotations from XML.
        /// </summary>
        /// <param name="xml"></param>
        public void Restore(string xml)
        {
            try
            {
                _annotations.Clear();
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(xml);
                XmlNode annotationsNode = doc.Node(0);
                foreach (XmlNode symbolNode in annotationsNode.ChildNodes)
                {
                    string symbol = symbolNode.Property("SYMBOL", "");
                    List<CacheableBrowserChartDrawingTools> annotations = new List<CacheableBrowserChartDrawingTools>();
                    foreach (XmlNode annotationNode in symbolNode.ChildNodes)
                    {
                        CacheableBrowserChartDrawingTools annotation = new CacheableBrowserChartDrawingTools();
                        annotation.Restore(annotationNode);
                        annotations.Add(annotation);
                    }
                    _annotations.Add(symbol, annotations);
                }
            }
            catch { }
        }
    }

    /// <summary>
    /// Generic object to cache a web browser drawing tools
    /// </summary>
    public class CacheableBrowserChartDrawingTools
    {
        public CacheableBrowserChartDrawingTools() { }

        public ChartTimeframe ChartTimeframe { get; set; }

        public string Content { get; set; } = string.Empty;

        ////public override bool Equals(object obj)
        ////{
        ////    CacheableBrowserChartAnnotation CacheableBrowserChartAnnotation = obj as CacheableBrowserChartAnnotation;
        ////    if (null == CacheableBrowserChartAnnotation)
        ////        return false;
        ////    return CacheableBrowserChartAnnotation.Id == Id;
        ////}

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        public void Save(XmlNode parent)
        {
            XmlNode newNode = parent.NewNode("BROWSER_CHARTS_ANNOTATION");
            newNode.SetProperty("TIMEFRAME", ChartTimeframe);
            newNode.InnerText = Content;
        }

        public void Restore(XmlNode description)
        {
            ChartTimeframe = description.PropertyEnum<ChartTimeframe>("TIMEFRAME", ChartTimeframe.Daily);
            Content = description.InnerText;
        }
    }
}