//
// Copyright (C) 2006, NinjaTrader LLC <www.ninjatrader.com>.
// NinjaTrader reserves the right to modify or overwrite this NinjaScript component with each release.
//
// Modified by MrJoe
//   14.may.2011 - first release
//   15.may.2011 - automatic resize of the closing tick line 
//

#region Using declarations
using System;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.ComponentModel;
using System.Xml.Serialization;
using NinjaTrader.Data;
using NinjaTrader.Gui.Chart;
#endregion

// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
    /// <summary>
    /// HLC Bars for VSA.
    /// </summary>
    [Description("HLC Bars for VSA")]
    public class HLCBars : Indicator
    {
        #region Variables
        private Color           savePenColor         = Color.Transparent;
        private Color           savePen2Color        = Color.Transparent;
        private Color           saveDownColor        = Color.Empty;
        private Color           saveUpColor          = Color.Empty;
        private Color           m_barColor           = Color.Gray;
        private Pen				m_barPen		     = null;
		private int             m_barWidth           = 0;
        #endregion

		
        /// <summary>
        /// This method is used to configure the indicator and is called once before any bar data is loaded.
        /// </summary>
        protected override void Initialize()
        {
            Add(new Plot(Color.Gray, PlotStyle.Line, "MOpen"));
            Add(new Plot(Color.Gray, PlotStyle.Line, "MHigh"));
            Add(new Plot(Color.Gray, PlotStyle.Line, "MLow"));
            Add(new Plot(Color.Gray, PlotStyle.Line, "MClose"));
			ZOrder				= 1;
            PaintPriceMarkers   = false;
            CalculateOnBarClose = false;
            PlotsConfigurable   = false;
            Overlay             = true;
        }

        /// <summary>
        /// Called on each bar update event (incoming tick)
        /// </summary>
        protected override void OnBarUpdate()
        {
			MClose.Set(Close[0]);
            MHigh.Set(High[0]);
            MLow.Set(Low[0]);
        }

        #region Properties


        [Browsable(false)]
        [XmlIgnore]
        public DataSeries MOpen
        {
            get { return Values[0]; }
        }

        [Browsable(false)]
        [XmlIgnore]
        public DataSeries MHigh
        {
            get { return Values[1]; }
        }

        [Browsable(false)]
        [XmlIgnore]
        public DataSeries MLow
        {
            get { return Values[2]; }
        }

        [Browsable(false)]
        [XmlIgnore]
        public DataSeries MClose
        {
            get { return Values[3]; }
        }	
		
        [Description("Forced HLC bar width (0 = use Data Series settings).")]
        [Category("Settings")]
        [Gui.Design.DisplayNameAttribute("Bar width")]
        public int HLCBarWidth
        {
            get { return m_barWidth; }
            set { m_barWidth = value; }
        }

        [XmlIgnore]
        [Description("Color of bars.")]
        [Category("Settings")]
        [Gui.Design.DisplayNameAttribute("Color of bars")]
        public Color HLCBarColor
        {
            get { return m_barColor; }
            set { m_barColor = value; }
        }

        [Browsable(false)]
        public string HLCBarColorSerialize
        {
            get { return Gui.Design.SerializableColor.ToString(m_barColor); }
            set { m_barColor = Gui.Design.SerializableColor.FromString(value); }
        }


        #endregion

		private int GetBarWidth()
		{
			if ( m_barWidth != 0 ) {
				return m_barWidth;
			}
			else {
				return Bars.BarsData.ChartStyle.BarWidthUI;
			}
		}
		
        protected override void OnStartUp()
        {
            if (ChartControl == null || Bars == null)
                return;
            savePenColor                        = Bars.BarsData.ChartStyle.Pen.Color;
            savePen2Color                       = Bars.BarsData.ChartStyle.Pen2.Color;
            saveUpColor                         = Bars.BarsData.ChartStyle.UpColor;
            saveDownColor                       = Bars.BarsData.ChartStyle.DownColor;
            Bars.BarsData.ChartStyle.Pen.Color  = Color.Empty;
            Bars.BarsData.ChartStyle.Pen2.Color = Color.Empty;
            Bars.BarsData.ChartStyle.DownColor  = Color.Empty;
            Bars.BarsData.ChartStyle.UpColor    = Color.Empty;
            m_barPen                            = new Pen(m_barColor, GetBarWidth());
       }

        protected override void OnTermination()
        {
            if (ChartControl != null && Bars != null)
            {
                Bars.BarsData.ChartStyle.Pen.Color = savePenColor;
                Bars.BarsData.ChartStyle.Pen2.Color = savePen2Color;
                Bars.BarsData.ChartStyle.UpColor = saveUpColor;
                Bars.BarsData.ChartStyle.DownColor = saveDownColor;
            }

            if (m_barPen != null) m_barPen.Dispose();
       }

        public override void Plot(Graphics graphics, Rectangle bounds, double min, double max)
        {
			if (Bars == null || ChartControl == null)
                return;

			if ( GetBarWidth() != m_barPen.Width ) {
				m_barPen.Dispose();
				m_barPen = new Pen(m_barColor, GetBarWidth());
			}
			
			int tickWidth = Math.Max(3, 2 + 3 * (GetBarWidth() - 1));
			
            for (int idx = FirstBarIndexPainted; idx <= LastBarIndexPainted; idx++)
            {
                if (idx - Displacement < 0 || idx - Displacement >= BarsArray[0].Count || (!ChartControl.ShowBarsRequired && idx - Displacement < BarsRequired))
                    continue;
                double valH = MHigh.Get(idx);
                double valL = MLow.Get(idx);
                double valC = MClose.Get(idx);
                int x = ChartControl.GetXByBarIdx(BarsArray[0], idx);
                int y2 = ChartControl.GetYByValue(this, valH);
                int y3 = ChartControl.GetYByValue(this, valL);
                int y4 = ChartControl.GetYByValue(this, valC);

                graphics.DrawLine(m_barPen, x, y2, x, y3);
				graphics.DrawLine(m_barPen, x, y4, x + tickWidth, y4);
            }
        }

    }
}

#region NinjaScript generated code. Neither change nor remove.
// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
    public partial class Indicator : IndicatorBase
    {
        private HLCBars[] cacheHLCBars = null;

        private static HLCBars checkHLCBars = new HLCBars();

        /// <summary>
        /// HLC Bars for VSA
        /// </summary>
        /// <returns></returns>
        public HLCBars HLCBars()
        {
            return HLCBars(Input);
        }

        /// <summary>
        /// HLC Bars for VSA
        /// </summary>
        /// <returns></returns>
        public HLCBars HLCBars(Data.IDataSeries input)
        {
            if (cacheHLCBars != null)
                for (int idx = 0; idx < cacheHLCBars.Length; idx++)
                    if (cacheHLCBars[idx].EqualsInput(input))
                        return cacheHLCBars[idx];

            lock (checkHLCBars)
            {
                if (cacheHLCBars != null)
                    for (int idx = 0; idx < cacheHLCBars.Length; idx++)
                        if (cacheHLCBars[idx].EqualsInput(input))
                            return cacheHLCBars[idx];

                HLCBars indicator = new HLCBars();
                indicator.BarsRequired = BarsRequired;
                indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
                indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
                indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
                indicator.Input = input;
                Indicators.Add(indicator);
                indicator.SetUp();

                HLCBars[] tmp = new HLCBars[cacheHLCBars == null ? 1 : cacheHLCBars.Length + 1];
                if (cacheHLCBars != null)
                    cacheHLCBars.CopyTo(tmp, 0);
                tmp[tmp.Length - 1] = indicator;
                cacheHLCBars = tmp;
                return indicator;
            }
        }
    }
}

// This namespace holds all market analyzer column definitions and is required. Do not change it.
namespace NinjaTrader.MarketAnalyzer
{
    public partial class Column : ColumnBase
    {
        /// <summary>
        /// HLC Bars for VSA
        /// </summary>
        /// <returns></returns>
        [Gui.Design.WizardCondition("Indicator")]
        public Indicator.HLCBars HLCBars()
        {
            return _indicator.HLCBars(Input);
        }

        /// <summary>
        /// HLC Bars for VSA
        /// </summary>
        /// <returns></returns>
        public Indicator.HLCBars HLCBars(Data.IDataSeries input)
        {
            return _indicator.HLCBars(input);
        }
    }
}

// This namespace holds all strategies and is required. Do not change it.
namespace NinjaTrader.Strategy
{
    public partial class Strategy : StrategyBase
    {
        /// <summary>
        /// HLC Bars for VSA
        /// </summary>
        /// <returns></returns>
        [Gui.Design.WizardCondition("Indicator")]
        public Indicator.HLCBars HLCBars()
        {
            return _indicator.HLCBars(Input);
        }

        /// <summary>
        /// HLC Bars for VSA
        /// </summary>
        /// <returns></returns>
        public Indicator.HLCBars HLCBars(Data.IDataSeries input)
        {
            if (InInitialize && input == null)
                throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");

            return _indicator.HLCBars(input);
        }
    }
}
#endregion