using System;
using System.Collections.Generic;
using TradeIdeas.TIProData;
using TradeIdeas.TIProData.Configuration;
using TradeIdeas.TIProData.Interfaces;

namespace TradeIdeas.TIProGUI
{
    /// <summary>
    /// This is a generic interface for a config window.  This will allow us to make pluggable config windows.
    /// Different people might choose a different window, i.e. beginner, intermediate, advanced.  Perhaps
    /// more important, this allows us to try out new things.
    /// 
    /// This is also nice because of the number of different inputs to the config window.  We had constructor
    /// with a list of optional arguments that kept getting longer and longer.  And a few other ways of adding
    /// inputs.  Now the inputs and outputs are more clear.
    /// </summary>
    abstract public class ConfigWindowWrapper
    {
        /// <summary>
        /// Output.  After calling show it, use this to see the result.
        /// </summary>
        public PrepairedStrategy Strategy { get; protected set; }

        /// <summary>
        /// Output.
        /// True if the user hit the cancel button.
        /// False if <see cref="Strategy"/> is valid.
        /// </summary>
        public bool Canceled
        {
            get { return null == Strategy; }
        }
        /// <summary>
        /// Output.
        /// True if the user hit the cancel button.
        /// False if <see cref="VisibleCustomColumns"/> is not empty.
        /// </summary>
        public bool CanceledAIColumnConfig
        {
            get { return null == VisibleCustomColumns; }
        }

        /// <summary>
        /// Input.  Should we display the list of columns or not.
        /// The compare count window is an example that uses this.
        /// </summary>
        public bool HideColumns { get; set; }

        /// <summary>
        /// Input.  Should we show other pages.
        /// The multi-strategy window is an example that uses this.
        /// </summary>
        public bool OnlyShowColumns { get; set; }

        private readonly List<IDisplayColumn> _extraColumns = new List<IDisplayColumn>();
        public List<IDisplayColumn> ExtraColumns { get { return _extraColumns; } }

        /// <summary>
        /// Normally we require the user to change something before hitting OK.
        /// Set this property to true to disable that feature.
        /// </summary>
        public bool AllowOkayImmediately { get; set; }

        /// <summary>
        /// Input.
        /// The caller can suggest that we sort by a specific column.
        /// This is useful when a user right clicks on a column and asks to sort.
        /// The default of null means not to do anything special.
        /// </summary>
        public String SortBy { get; set; }

        /// <summary>
        /// Input.
        /// The caller can suggest a certain filter of interest.
        /// This is useful when a user right clicks on a column.
        /// The default of null means not to do anything special.
        /// </summary>
        public String InitialFilter { get; set; }

        /// <summary>
        /// Input.
        /// The caller can specify a specific value for a min filter
        /// be changed.
        /// </summary>
        public double? SetMinFilter { get; set; }

        /// <summary>
        /// Input.
        /// The caller can specify a specific value for a max filter
        /// be changed.
        /// </summary
        public double? SetMaxFilter { get; set; }

        /// <summary>
        /// Input.  This is actually set in the constructor because it's not optional and probably shouldn't change.
        /// </summary>
        public ConfigurationType ConfigurationType { get; private set; }

        /// <summary>
        /// Input.  This is actually set in the constructor because it's not optional and probably shouldn't change.
        /// </summary>
        public IConnectionMaster ConnectionMaster { get; private set; }

        /// <summary>
        /// Input.
        /// This is a collaborate string.
        /// Start by modifying this configuration.
        /// If this is null, start from scratch.
        /// </summary>
        public string InitialConfig { get; set; }

        /// <summary>
        /// By default the config window might display something like "window name" to the user.
        /// If you set this property to true, the window will change to something like "strategy name".
        /// </summary>
        public bool NotAWindow { get; set; }

        /// <summary>
        /// Are we using TopList data to produce a toplist window, or a "Single Stock Window"?
        /// </summary>
        public bool IsSingleStock { get; set; }

        /// <summary>
        /// Are we using the default strategy for the given window?
        /// Used to customize config window.
        /// </summary>
        public bool IsDefaultStrategy { get; set; }

        /// <summary>
        /// Below bool for when using the "column in results" option in oddsmaker, and we're using an abbreviated version of config window
        /// </summary>
        public bool UsingOddsMaker { get; set; }

        /// <summary>
        /// This is part of the name sent to the server when the user does anything interesting.
        /// For example, set this to "Odds", and the server might receive messages like 
        /// "ConfigWindow.Odds.StrategiesTab", when the user clicks on the strategies tab.
        /// The default value for this property is null.  If you leave it null, the code will
        /// try to pick a good value based on other factors.
        /// </summary>
        public string UseCaseName { get; set; }

        public List<MultiStrategy.DataWatcher> MultiStrategies { get; set; }

        public Dictionary<string, string> StrategyChanges { get; set; }
         //The below aids the determination the starting point for population of the singleStock window
        // it is set to either one or zero. In one case, the population begins on the right (right-left-right...etc)
        //whereas the other begins on the left (left-right-left...etc). How the user arranges his colums will
        //determine this value
        public int SingleStockWindowValue { get; set; }

        /// <summary>
        /// When using Custom Column chooser mode, use AllCustomColumns for all the columns available for choosing.
        /// </summary>
        public List<ColumnInfo> AllCustomColumns { get; set; }

        /// <summary>
        /// When using Custom Column chooser mode, use VisibleCustomColumns for the list of columns that are currently visible.
        /// </summary>
        public List<ColumnInfo> VisibleCustomColumns { get; set; }
        public int ColumnCount { get; internal set; }

        /// <summary>
        /// Each config window should create at least one of these.  
        /// This is necessary for <see cref="DefaultFactory"/>.
        /// But this can also allow us to chain config windows.  For example, the development version
        /// of the config window might bring up a dynamically populated list of choices, each of which
        /// is one of these.
        /// </summary>
        /// <param name="configurationType">Alert or Top List</param>
        /// <param name="connectionMaster">How to access the server.</param>
        /// <returns>A new ConfigWindowWrapper.</returns>
        public delegate ConfigWindowWrapper Factory(ConfigurationType configurationType,
            IConnectionMaster connectionMaster);

        /// <summary>
        /// Set Race Config Mode to true when called from RTSR.
        /// In this mode, the "Select Base" tab is hidden.
        /// </summary>
        public bool RaceConfigMode { get; set; }

        /// <summary>
        /// If you just want to display a config window, you start by calling DefaultFactory().
        /// </summary>
        //public static Factory DefaultFactory = TraditionalFactory;
        public static Factory DefaultFactory = TraditionalConfigWindowWrapper.Factory;

        abstract public void ShowIt();

        /// <summary>
        /// Copy all of the fields that as marked as inputs.  
        /// Leave the outputs in their default state.
        /// </summary>
        /// <param name="other">The new object is based on this one.</param>
        protected ConfigWindowWrapper(ConfigWindowWrapper other)
        {
            HideColumns = other.HideColumns;
            OnlyShowColumns = other.OnlyShowColumns;
            _extraColumns.AddRange(other._extraColumns);
            AllowOkayImmediately = other.AllowOkayImmediately;
            SortBy = other.SortBy;
            InitialFilter = other.InitialFilter;
            ConfigurationType = other.ConfigurationType;
            ConnectionMaster = other.ConnectionMaster;
            InitialConfig = other.InitialConfig;
            NotAWindow = other.NotAWindow;
            UseCaseName = other.UseCaseName;
            IsSingleStock = other.IsSingleStock;
            UsingOddsMaker = other.UsingOddsMaker;
            ColumnCount = other.ColumnCount;
        }

        /// <summary>
        /// Keep all the defaults.
        /// The parameters are items with no reasonable default.
        /// </summary>
        /// <param name="configurationType">Alert or Top List</param>
        /// <param name="connectionMaster">How to talk to the server.</param>
        protected ConfigWindowWrapper(ConfigurationType configurationType, IConnectionMaster connectionMaster)
        {
            ConfigurationType = configurationType;
            ConnectionMaster = connectionMaster;
        }

    }
    /// <summary>
    /// This is a wrapper around the config window that we've had for a while.
    /// </summary>
    public class TraditionalConfigWindowWrapper : ConfigWindowWrapper
    {
        public TraditionalConfigWindowWrapper(ConfigurationType configurationType, IConnectionMaster connectionMaster) :
            base(configurationType, connectionMaster)
        {
        }
        public TraditionalConfigWindowWrapper(ConfigWindowWrapper other) :
            base(other)
        {
        }
        public static new ConfigWindowWrapper Factory(ConfigurationType configurationType,
                                                      IConnectionMaster connectionMaster)
        {
            return new TraditionalConfigWindowWrapper(configurationType, connectionMaster);
        }

        public override void ShowIt()
        {
            using (ConfigWindow configWindow = new ConfigWindow(ConfigurationType, ConnectionMaster, InitialConfig, columnChooserMode: OnlyShowColumns, fromScratch: AllowOkayImmediately, dontShowColumns: HideColumns, extraColumns: ExtraColumns.AsReadOnly(), useCaseName: UseCaseName, notAWindow: NotAWindow, multiStrategies: MultiStrategies, isSingleStock: IsSingleStock, usingOddsMaker: UsingOddsMaker, setMinFilter: SetMinFilter, setMaxFilter: SetMaxFilter, allCustomColumns: AllCustomColumns, allVisibleCustomColumns: VisibleCustomColumns, columnCount:ColumnCount))
            {
                if (null != SortBy)
                    configWindow.serverSortFromOutside(SortBy);
                if (null != InitialFilter)
                {
                    configWindow.configFromOutside(InitialFilter, SetMinFilter, SetMaxFilter);
                }
                if(ConfigurationType == TIProData.Configuration.ConfigurationType.CustomColumns)
                {
                    configWindow.ShowDialog();
                    if (configWindow.DialogResult == System.Windows.Forms.DialogResult.OK)
                        VisibleCustomColumns = configWindow.GetVisibleCustomColumns();
                    else
                        VisibleCustomColumns = null;
                }
                else
                {
                    configWindow.setListStart(SingleStockWindowValue);
                    configWindow.showWaitPanel();
                    configWindow.ShowDialog();
                    if (configWindow.DialogResult == System.Windows.Forms.DialogResult.OK)
                    {
                        Strategy = configWindow.Strategy;
                        StrategyChanges = configWindow.StrategyChanges;
                        SingleStockWindowValue = configWindow.getListStart();
                    }
                    else
                    {
                        Strategy = null;
                    }
                }
            }
        }
    }
}