using System;
using System.Collections.Generic;
using System.Data;
using System.ComponentModel;
using System.Collections;
using FastReport.Utils;
using System.Drawing.Design;

namespace FastReport.Data
{
    /// <summary>
    /// Base class for all datasources such as <see cref="TableDataSource"/>.
    /// </summary>
    [TypeConverter(typeof(FastReport.TypeConverters.DataSourceConverter))]
    [Editor("FastReport.TypeEditors.DataSourceEditor, FastReport", typeof(UITypeEditor))]
    public abstract class DataSourceBase : Column
    {
        #region Fields
        private ArrayList internalRows;
        private ArrayList rows;
        private int currentRowNo;
        protected object currentRow;
        private Hashtable additionalFilter;
        private bool forceLoadData;
        private Hashtable columnIndices;
        private Hashtable rowIndices;
        private Hashtable relation_SortedChildRows;
        private static bool FShowAccessDataMessage;
        #endregion

        #region Properties
        /// <summary>
        /// Occurs when the FastReport engine loads data source with data.
        /// </summary>
        /// <remarks>
        /// Use this event if you want to implement load-on-demand. Event handler must load the data 
        /// into the data object which this datasource is bound to (for example, the
        /// <b>TableDataSource</b> uses data from the <b>DataTable</b> object bound to
        /// the <b>Table</b> property).
        /// </remarks>
        public event EventHandler Load;

        /// <summary>
        /// Gets or sets alias of this object.
        /// </summary>
        /// <remarks>
        /// Alias is a human-friendly name of this object. It may contain any symbols (including 
        /// spaces and national symbols).
        /// </remarks>
        [Category("Design")]
        public new string Alias
        {
            get { return base.Alias; }
            set
            {
                UpdateExpressions(base.Alias, value);
                base.Alias = value;
            }
        }

        /// <summary>
        /// Gets a number of data rows in this datasource.
        /// </summary>
        /// <remarks>
        /// You should initialize the datasource by the <b>Init</b> method before using this property.
        /// </remarks>
        [Browsable(false)]
        public int RowCount
        {
            get { return rows.Count; }
        }

        /// <summary>
        /// Gets a value indicating that datasource has more rows, that is the <see cref="CurrentRowNo"/>
        /// is less than the <see cref="RowCount"/>.
        /// </summary>
        /// <remarks>
        /// <para>You should initialize the datasource by the <b>Init</b> method before using this property.</para>
        /// <para>Usually this property is used with the following code block:</para>
        /// <code>
        /// dataSource.Init();
        /// while (dataSource.HasMoreRows)
        /// {
        ///   // do something...
        ///   dataSource.Next();
        /// }
        /// </code>
        /// </remarks>
        [Browsable(false)]
        public bool HasMoreRows
        {
            get { return CurrentRowNo < RowCount; }
        }

        /// <summary>
        /// Gets the current data row.
        /// </summary>
        /// <remarks>
        /// <para>This property is updated when you call the <see cref="Next"/> method.</para>
        /// </remarks>
        [Browsable(false)]
        public object CurrentRow
        {
            get
            {
                // in case we trying to print a datasource column in report title, init the datasource
                if (InternalRows.Count == 0)
                    Init();
                return currentRow;
            }
        }

        /// <summary>
        /// Gets an index of current data row.
        /// </summary>
        /// <remarks>
        /// <para>You should initialize the datasource by the <b>Init</b> method before using this property.</para>
        /// <para>This property is updated when you call the <see cref="Next"/> method.</para>
        /// </remarks>
        [Browsable(false)]
        public int CurrentRowNo
        {
            get { return currentRowNo; }
            set
            {
                currentRowNo = value;
                if (value >= 0 && value < rows.Count)
                    currentRow = rows[value];
                else
                    currentRow = null;
            }
        }

        /// <summary>
        /// Gets data stored in a specified column.
        /// </summary>
        /// <param name="columnAlias">Alias of a column.</param>
        /// <returns>The column's value.</returns>
        /// <remarks>
        /// You should initialize the datasource by the <b>Init</b> method before using this property.
        /// </remarks>
        [Browsable(false)]
        public object this[string columnAlias]
        {
            get
            {
                return GetValue(columnAlias);
            }
        }

        /// <summary>
        /// Gets data stored in a specified column.
        /// </summary>
        /// <param name="column">The column.</param>
        /// <returns>The column's value.</returns>
        /// <remarks>
        /// You should initialize the datasource by the <b>Init</b> method before using this property.
        /// </remarks>
        [Browsable(false)]
        public object this[Column column]
        {
            get
            {
                if (InternalRows.Count == 0)
                    Init();
                if (column.Calculated)
                    return column.Value;
                return GetValue(column);
            }
        }

        /// <summary>
        /// Forces loading of data for this datasource.
        /// </summary>
        /// <remarks>
        /// This property is <b>false</b> by default. Set it to <b>true</b> if you need to reload data 
        /// each time when the datasource initialized. Note that this may slow down the performance.
        /// </remarks>
        [DefaultValue(false)]
        public bool ForceLoadData
        {
            get { return forceLoadData; }
            set { forceLoadData = value; }
        }

        /// <summary>
        /// This property is not relevant to this class.
        /// </summary>
        [Browsable(false)]
        public new Type DataType
        {
            get { return base.DataType; }
            set { base.DataType = value; }
        }

        /// <summary>
        /// This property is not relevant to this class.
        /// </summary>
        [Browsable(false)]
        public new ColumnBindableControl BindableControl
        {
            get { return base.BindableControl; }
            set { base.BindableControl = value; }
        }

        /// <summary>
        /// This property is not relevant to this class.
        /// </summary>
        [Browsable(false)]
        public new string CustomBindableControl
        {
            get { return base.CustomBindableControl; }
            set { base.CustomBindableControl = value; }
        }

        /// <summary>
        /// This property is not relevant to this class.
        /// </summary>
        [Browsable(false)]
        public new ColumnFormat Format
        {
            get { return base.Format; }
            set { base.Format = value; }
        }

        /// <summary>
        /// This property is not relevant to this class.
        /// </summary>
        [Browsable(false)]
        public new string Expression
        {
            get { return base.Expression; }
            set { base.Expression = value; }
        }

        /// <summary>
        /// This property is not relevant to this class.
        /// </summary>
        [Browsable(false)]
        public new bool Calculated
        {
            get { return base.Calculated; }
            set { base.Calculated = value; }
        }

        /// <summary>
        /// Gets the additional filter settings.
        /// </summary>
        internal Hashtable AdditionalFilter
        {
            get { return additionalFilter; }
        }

        internal ArrayList Rows
        {
            get { return rows; }
        }

        internal ArrayList InternalRows
        {
            get { return internalRows; }
        }
        #endregion

        #region Private Methods

        private void GetChildRows(Relation relation)
        {
            // prepare consts
            object parentRow = relation.ParentDataSource.CurrentRow;
            int columnsCount = relation.ParentColumns.Length;
            object[] parentValues = new object[columnsCount];
            Column[] childColumns = new Column[columnsCount];
            for (int i = 0; i < columnsCount; i++)
            {
                parentValues[i] = relation.ParentDataSource[relation.ParentColumns[i]];
                childColumns[i] = Columns.FindByAlias(relation.ChildColumns[i]);
            }

            if (relation_SortedChildRows == null)
                relation_SortedChildRows = new Hashtable();

            // sort the child table at the first run. Use relation columns to sort.
            SortedList<Indices, ArrayList> sortedChildRows = relation_SortedChildRows[relation] as SortedList<Indices, ArrayList>;
            if (sortedChildRows == null)
            {
                sortedChildRows = new SortedList<Indices, ArrayList>();
                relation_SortedChildRows[relation] = sortedChildRows;
                foreach (object row in InternalRows)
                {
                    SetCurrentRow(row);

                    object[] values = new object[columnsCount];
                    for (int i = 0; i < columnsCount; i++)
                    {
                        values[i] = this[childColumns[i]];
                    }

                    Indices indices = new Indices(values);
                    ArrayList rows = null;
                    int index = sortedChildRows.IndexOfKey(indices);
                    if (index == -1)
                    {
                        rows = new ArrayList();
                        sortedChildRows.Add(indices, rows);
                    }
                    else
                        rows = sortedChildRows.Values[index];

                    rows.Add(row);
                }
            }

            int indexOfKey = sortedChildRows.IndexOfKey(new Indices(parentValues));
            if (indexOfKey != -1)
            {
                ArrayList rows = sortedChildRows.Values[indexOfKey];
                foreach (object row in rows)
                {
                    this.rows.Add(row);
                }
            }
        }

        private void ApplyAdditionalFilter()
        {
            for (int i = 0; i < rows.Count; i++)
            {
                CurrentRowNo = i;
                foreach (DictionaryEntry de in AdditionalFilter)
                {
                    object value = Report.GetColumnValueNullable((string)de.Key);
                    DataSourceFilter filter = de.Value as DataSourceFilter;

                    if (!filter.ValueMatch(value))
                    {
                        rows.RemoveAt(i);
                        i--;
                        break;
                    }
                }
            }
        }

        private void UpdateExpressions(string oldAlias, string newAlias)
        {
            if (Report != null)
            {
                // Update expressions in components.
                foreach (Base component in Report.AllObjects)
                {
                    // Update Text in TextObject instances.
                    if (component is TextObject)
                    {
                        TextObject text = component as TextObject;
                        string bracket = text.Brackets.Split(new char[] { ',' })[0];
                        if (String.IsNullOrEmpty(bracket))
                        {
                            bracket = "[";
                        }
                        text.Text = text.Text.Replace(bracket + oldAlias + ".", bracket + newAlias + ".");
                    }
                    // Update DataColumn in PictureObject instances.
                    else if (component is PictureObject)
                    {
                        PictureObject picture = component as PictureObject;
                        picture.DataColumn = picture.DataColumn.Replace(oldAlias + ".", newAlias + ".");
                    }
                    // Update Filter and Sort in DataBand instances.
                    else if (component is DataBand)
                    {
                        DataBand data = component as DataBand;
                        data.Filter = data.Filter.Replace("[" + oldAlias + ".", "[" + newAlias + ".");
                        foreach (Sort sort in data.Sort)
                        {
                            sort.Expression = sort.Expression.Replace("[" + oldAlias + ".", "[" + newAlias + ".");
                        }
                    }
                }
            }
        }

        #endregion

        #region Protected Methods
        /// <summary>
        /// Gets data stored in a specified column.
        /// </summary>
        /// <param name="alias">The column alias.</param>
        /// <returns>An object that contains the data.</returns>
        protected virtual object GetValue(string alias)
        {
            Column column = columnIndices[alias] as Column;
            if (column == null)
            {
                column = Columns.FindByAlias(alias);
                columnIndices[alias] = column;
            }

            return GetValue(column);
        }

        /// <summary>
        /// Gets data stored in a specified column.
        /// </summary>
        /// <param name="column">The column.</param>
        /// <returns>An object that contains the data.</returns>
        protected abstract object GetValue(Column column);
        #endregion

        #region Public Methods
        /// <summary>
        /// Initializes the datasource schema.
        /// </summary>
        /// <remarks>
        /// This method is used to support the FastReport.Net infrastructure. Do not call it directly.
        /// </remarks>
        public abstract void InitSchema();

        /// <summary>
        /// Loads the datasource with data.
        /// </summary>
        /// <remarks>
        /// This method is used to support the FastReport.Net infrastructure. Do not call it directly.
        /// </remarks>
        /// <param name="rows">Rows to fill with data.</param>
        public abstract void LoadData(ArrayList rows);

        internal void LoadData()
        {
            LoadData(InternalRows);
        }

        internal void OnLoad()
        {
            if (Load != null)
            {
                // clear internal rows to force reload data
                InternalRows.Clear();
                Load(this, EventArgs.Empty);
            }
        }

        internal void SetCurrentRow(object row)
        {
            currentRow = row;
        }

        internal void FindParentRow(Relation relation)
        {
            InitSchema();
            LoadData();

            int columnCount = relation.ChildColumns.Length;
            object[] childValues = new object[columnCount];
            for (int i = 0; i < columnCount; i++)
            {
                childValues[i] = relation.ChildDataSource[relation.ChildColumns[i]];
            }

            object result = null;
            if (childValues[0] == null)
            {
                SetCurrentRow(null);
                return;
            }

            // improve performance for single column index
            if (columnCount == 1)
            {
                if (rowIndices.Count == 0)
                {
                    foreach (object row in InternalRows)
                    {
                        SetCurrentRow(row);
                        rowIndices[this[relation.ParentColumns[0]]] = row;
                    }
                }

                result = rowIndices[childValues[0]];
                if (result != null)
                {
                    SetCurrentRow(result);
                    return;
                }
            }

            foreach (object row in InternalRows)
            {
                SetCurrentRow(row);
                bool found = true;

                for (int i = 0; i < columnCount; i++)
                {
                    if (!this[relation.ParentColumns[i]].Equals(childValues[i]))
                    {
                        found = false;
                        break;
                    }
                }
                if (found)
                {
                    result = row;
                    break;
                }
            }

            if (columnCount == 1)
                rowIndices[childValues[0]] = result;

            SetCurrentRow(result);
        }

        /// <summary>
        /// Initializes this datasource.
        /// </summary>
        /// <remarks>
        /// This method fills the table with data. You should always call it before using most of
        /// datasource properties.
        /// </remarks>
        public void Init()
        {
            Init("");
        }

        /// <summary>
        /// Initializes this datasource and applies the specified filter.
        /// </summary>
        /// <param name="filter">The filter expression.</param>
        public void Init(string filter)
        {
            Init(filter, null);
        }

        /// <summary>
        /// Initializes this datasource, applies the specified filter and sorts the rows.
        /// </summary>
        /// <param name="filter">The filter expression.</param>
        /// <param name="sort">The collection of sort descriptors.</param>
        public void Init(string filter, SortCollection sort)
        {
            DataSourceBase parentData = null;
            Init(parentData, filter, sort);
        }

        /// <summary>
        /// Initializes this datasource and filters data rows according to the master-detail relation between
        /// this datasource and <b>parentData</b>.
        /// </summary>
        /// <param name="parentData">Parent datasource.</param>
        /// <remarks>
        /// To use master-detail relation, you must define the <see cref="Relation"/> object that describes
        /// the relation, and add it to the <b>Report.Dictionary.Relations</b> collection.
        /// </remarks>
        public void Init(DataSourceBase parentData)
        {
            Init(parentData, "", null);
        }

        /// <summary>
        /// Initializes this datasource and filters data rows according to the master-detail relation between
        /// this datasource and <b>parentData</b>. Also applies the specified filter and sorts the rows.
        /// </summary>
        /// <param name="parentData">Parent datasource.</param>
        /// <param name="filter">The filter expression.</param>
        /// <param name="sort">The collection of sort descriptors.</param>
        /// <remarks>
        /// To use master-detail relation, you must define the <see cref="Relation"/> object that describes
        /// the relation, and add it to the <b>Report.Dictionary.Relations</b> collection.
        /// </remarks>
        public void Init(DataSourceBase parentData, string filter, SortCollection sort)
        {
            Init(parentData, filter, sort, false);
        }

        /// <summary>
        /// Initializes this datasource and filters data rows according to the master-detail relation.
        /// Also applies the specified filter and sorts the rows.
        /// </summary>
        /// <param name="relation">The master-detail relation.</param>
        /// <param name="filter">The filter expression.</param>
        /// <param name="sort">The collection of sort descriptors.</param>
        /// <remarks>
        /// To use master-detail relation, you must define the <see cref="Relation"/> object that describes
        /// the relation, and add it to the <b>Report.Dictionary.Relations</b> collection.
        /// </remarks>
        public void Init(Relation relation, string filter, SortCollection sort)
        {
            Init(relation, filter, sort, false);
        }

        internal void Init(DataSourceBase parentData, string filter, SortCollection sort, bool useAllParentRows)
        {
            Relation relation = parentData != null ? DataHelper.FindRelation(Report.Dictionary, parentData, this) : null;
            Init(relation, filter, sort, useAllParentRows);
        }

        internal void Init(Relation relation, string filter, SortCollection sort, bool useAllParentRows)
        {
            if (FShowAccessDataMessage)
                Config.ReportSettings.OnProgress(Report, Res.Get("Messages,AccessingData"));

            // InitSchema may fail sometimes (for example, when using OracleConnection with nested select).
            try
            {
                InitSchema();
            }
            catch
            {
            }
            LoadData();

            // fill rows, emulate relation
            rows.Clear();
            if (relation != null && relation.Enabled)
            {
                if (useAllParentRows)
                {
                    DataSourceBase parentData = relation.ParentDataSource;
                    // parentData must be initialized prior to calling this method!
                    parentData.First();
                    while (parentData.HasMoreRows)
                    {
                        GetChildRows(relation);
                        parentData.Next();
                    }
                }
                else
                    GetChildRows(relation);
            }
            else
            {
                foreach (object row in InternalRows)
                {
                    rows.Add(row);
                }
            }

            // filter data rows
            if (FShowAccessDataMessage && rows.Count > 10000)
                Config.ReportSettings.OnProgress(Report, Res.Get("Messages,PreparingData"));

            if (filter != null && filter.Trim() != "")
            {
                for (int i = 0; i < rows.Count; i++)
                {
                    CurrentRowNo = i;
                    object match = Report.Calc(filter);
                    if (match is bool && !(bool)match)
                    {
                        rows.RemoveAt(i);
                        i--;
                    }
                }
            }

            // additional filter
            if (AdditionalFilter.Count > 0)
                ApplyAdditionalFilter();

            // sort data rows
            if (sort != null && sort.Count > 0)
            {
                string[] expressions = new string[sort.Count];
                bool[] descending = new bool[sort.Count];
                for (int i = 0; i < sort.Count; i++)
                {
                    expressions[i] = sort[i].Expression;
                    descending[i] = sort[i].Descending;
                }
                rows.Sort(new RowComparer(Report, this, expressions, descending));
            }

            FShowAccessDataMessage = false;
            First();
        }

        /// <summary>
        /// Initializes the data source if it is not initialized yet.
        /// </summary>
        public void EnsureInit()
        {
            if (InternalRows.Count == 0)
                Init();
        }

        /// <summary>
        /// Navigates to the first row.
        /// </summary>
        /// <remarks>
        /// You should initialize the datasource by the <b>Init</b> method before using this method.
        /// </remarks>
        public void First()
        {
            CurrentRowNo = 0;
        }

        /// <summary>
        /// Navigates to the next row.
        /// </summary>
        /// <remarks>
        /// You should initialize the datasource by the <b>Init</b> method before using this method.
        /// </remarks>
        public void Next()
        {
            CurrentRowNo++;
        }

        /// <summary>
        /// Navigates to the prior row.
        /// </summary>
        /// <remarks>
        /// You should initialize the datasource by the <b>Init</b> method before using this method.
        /// </remarks>
        public void Prior()
        {
            CurrentRowNo--;
        }

        /// <inheritdoc/>
        public override void Serialize(FRWriter writer)
        {
            base.Serialize(writer);
            if (Enabled)
                writer.WriteBool("Enabled", Enabled);
            if (ForceLoadData)
                writer.WriteBool("ForceLoadData", ForceLoadData);
        }

        /// <inheritdoc/>
        public override void Deserialize(FRReader reader)
        {
            // the Clear is needed to avoid duplicate columns in the inherited report
            // when the same datasource is exists in both base and inherited report
            Clear();
            base.Deserialize(reader);
        }

        internal void ClearData()
        {
            columnIndices.Clear();
            rowIndices.Clear();
            InternalRows.Clear();
            Rows.Clear();
            additionalFilter.Clear();
            relation_SortedChildRows = null;
            FShowAccessDataMessage = true;
        }

        /// <inheritdoc/>
        public override void InitializeComponent()
        {
            ClearData();
        }
        #endregion

        /// <summary>
        /// Initializes a new instance of the <see cref="DataSourceBase"/> class with default settings.
        /// </summary>
        public DataSourceBase()
        {
            internalRows = new ArrayList();
            rows = new ArrayList();
            additionalFilter = new Hashtable();
            columnIndices = new Hashtable();
            rowIndices = new Hashtable();
            SetFlags(Flags.HasGlobalName, true);
        }

        private class RowComparer : IComparer
        {
            private Report report;
            private DataSourceBase dataSource;
            private string[] expressions;
            private bool[] descending;
            private Column[] columns;

            public int Compare(object x, object y)
            {
                int result = 0;
                for (int i = 0; i < expressions.Length; i++)
                {
                    IComparable i1;
                    IComparable i2;
                    if (columns[i] == null)
                    {
                        dataSource.SetCurrentRow(x);
                        i1 = report.Calc(expressions[i]) as IComparable;
                        dataSource.SetCurrentRow(y);
                        i2 = report.Calc(expressions[i]) as IComparable;
                    }
                    else
                    {
                        dataSource.SetCurrentRow(x);
                        i1 = columns[i].Value as IComparable;
                        dataSource.SetCurrentRow(y);
                        i2 = columns[i].Value as IComparable;
                    }

                    if (i1 != null)
                        result = i1.CompareTo(i2);
                    else if (i2 != null)
                        result = -1;
                    if (descending[i])
                        result = -result;
                    if (result != 0)
                        break;
                }
                return result;
            }

            public RowComparer(Report report, DataSourceBase dataSource, string[] expressions, bool[] descending)
            {
                this.report = report;
                this.dataSource = dataSource;
                this.expressions = expressions;
                this.descending = descending;

                // optimize performance if expression is a single data column
                columns = new Column[expressions.Length];
                for (int i = 0; i < expressions.Length; i++)
                {
                    string expr = expressions[i];
                    if (expr.StartsWith("[") && expr.EndsWith("]"))
                        expr = expr.Substring(1, expr.Length - 2);
                    Column column = DataHelper.GetColumn(this.report.Dictionary, expr);
                    DataSourceBase datasource = DataHelper.GetDataSource(this.report.Dictionary, expr);
                    if (column != null && column.Parent == datasource)
                        columns[i] = column;
                    else
                        columns[i] = null;
                }
            }
        }

        private class Indices : IComparable
        {
            private object[] values;

            public int CompareTo(object obj)
            {
                Indices indices = obj as Indices;

                int result = 0;
                for (int i = 0; i < values.Length; i++)
                {
                    IComparable i1 = indices.values[i] as IComparable;
                    IComparable i2 = values[i] as IComparable;

                    if (i1 != null)
                        result = i1.CompareTo(i2);
                    else if (i2 != null)
                        result = -1;
                    if (result != 0)
                        break;
                }
                return result;
            }

            public Indices(object[] values)
            {
                this.values = values;
            }
        }
    }
}