//------------------------------------------------------------------------------
// <copyright file="DataRowView.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
// <owner current="true" primary="true">[....]</owner>
// <owner current="true" primary="false">[....]</owner>
//------------------------------------------------------------------------------

namespace System.Data {
    using System.Diagnostics;
    using System.ComponentModel;

    public class DataRowView : ICustomTypeDescriptor, System.ComponentModel.IEditableObject, System.ComponentModel.IDataErrorInfo, System.ComponentModel.INotifyPropertyChanged {

        private readonly DataView dataView;
        private readonly DataRow _row;
        private bool delayBeginEdit;

        private static PropertyDescriptorCollection zeroPropertyDescriptorCollection = new PropertyDescriptorCollection(null);

        /// <summary>
        /// When the PropertyChanged event happens, it must happen on the same DataRowView reference.
        /// This is so a generic event handler like Windows Presentation Foundation can redirect as appropriate.
        /// Having DataView.Equals is not sufficient for WPF, because two different instances may be equal but not equivalent.
        /// For DataRowView, if two instances are equal then they are equivalent.
        /// </summary>
        private System.ComponentModel.PropertyChangedEventHandler  onPropertyChanged;

        internal DataRowView(DataView dataView, DataRow row)
        {
            this.dataView = dataView;
            this._row = row;
        }

        /// <remarks>
        /// Checks for same reference instead of equivalent <see cref="DataView"/> or <see cref="Row"/>.
        /// 
        /// Necessary for ListChanged event handlers to use data structures that use the default to
        /// <see cref="Object.Equals(Object)"/> instead of <see cref="Object.ReferenceEquals"/>
        /// to understand if they need to add a <see cref="PropertyChanged"/> event handler.
        /// </remarks>
        /// <returns><see cref="Object.ReferenceEquals"/></returns>
        public override bool Equals(object other) {
            return Object.ReferenceEquals(this, other);
        }

        /// <returns>Hashcode of <see cref="Row"/></returns>
        public override Int32 GetHashCode() {
            // Everett compatability, must return hashcode for DataRow
            // this does prevent using this object in collections like Hashtable
            // which use the hashcode as an immutable value to identify this object
            // user could/should have used the DataRow property instead of the hashcode
            return Row.GetHashCode();
        }

        public DataView DataView {
            get {
                return dataView;
            }
        }

        internal int ObjectID {
            get { return _row.ObjectID; }
        }

        /// <summary>Gets or sets a value in specified column.</summary>
        /// <param name="ndx">Specified column index.</param>
        /// <remarks>Uses either <see cref="DataRowVersion.Default"/> or <see cref="DataRowVersion.Original"/> to access <see cref="Row"/></remarks>
        /// <exception cref="DataException"><see cref="System.Data.DataView.get_AllowEdit"/> when setting a value.</exception>
        /// <exception cref="IndexOutOfRangeException"><see cref="DataColumnCollection.get_Item(int)"/></exception>
        public object this[int ndx] {
            get {
                return Row[ndx, RowVersionDefault];
            }
            set {
                if (!dataView.AllowEdit && !IsNew) {
                    throw ExceptionBuilder.CanNotEdit();
                }
                SetColumnValue(dataView.Table.Columns[ndx], value);
            }
        }

        /// <summary>Gets the specified column value or related child view or sets a value in specified column.</summary>
        /// <param name="property">Specified column or relation name when getting.  Specified column name when setting.</param>
        /// <exception cref="ArgumentException"><see cref="DataColumnCollection.get_Item(string)"/> when <paramref name="property"/> is ambigous.</exception>
        /// <exception cref="ArgumentException">Unmatched <paramref name="property"/> when getting a value.</exception>
        /// <exception cref="DataException">Unmatched <paramref name="property"/> when setting a value.</exception>
        /// <exception cref="DataException"><see cref="System.Data.DataView.get_AllowEdit"/> when setting a value.</exception>
        public object this[string property] {
            get {
                DataColumn column = dataView.Table.Columns[property];
                if (null != column) {
                    return Row[column, RowVersionDefault];
                }
                else if (dataView.Table.DataSet != null && dataView.Table.DataSet.Relations.Contains(property)) {
                    return CreateChildView(property);
                }
                throw ExceptionBuilder.PropertyNotFound(property, dataView.Table.TableName);
            }
            set {
                DataColumn column = dataView.Table.Columns[property];
                if (null == column) {
                    throw ExceptionBuilder.SetFailed(property);
                }
                if (!dataView.AllowEdit && !IsNew) {
                    throw ExceptionBuilder.CanNotEdit();
                }
                SetColumnValue(column, value);
            }
        }

        // IDataErrorInfo stuff
        string System.ComponentModel.IDataErrorInfo.this[string colName] {
            get {
                return Row.GetColumnError(colName);
            }
        }

        string System.ComponentModel.IDataErrorInfo.Error {
            get {
                return Row.RowError;
            }
        }
        
        /// <summary>
        /// Gets the current version description of the <see cref="DataRow"/>
        /// in relation to <see cref="System.Data.DataView.get_RowStateFilter"/>
        /// </summary>
        /// <returns>Either <see cref="DataRowVersion.Current"/> or <see cref="DataRowVersion.Original"/></returns>
        public DataRowVersion RowVersion {
            get {
                return (RowVersionDefault & ~DataRowVersion.Proposed);
            }
        }

        /// <returns>Either <see cref="DataRowVersion.Default"/> or <see cref="DataRowVersion.Original"/></returns>
        private DataRowVersion RowVersionDefault {
            get {
                return Row.GetDefaultRowVersion(dataView.RowStateFilter);
            }
        }

        internal int GetRecord() {
            return Row.GetRecordFromVersion(RowVersionDefault);
        }

        internal bool HasRecord() {
            return Row.HasVersion(RowVersionDefault);
        }

        internal object GetColumnValue(DataColumn column) {
            return Row[column, RowVersionDefault];
        }

        internal void SetColumnValue(DataColumn column, object value) {
            if (delayBeginEdit) {
                delayBeginEdit = false;
                Row.BeginEdit();
            }
            if (DataRowVersion.Original == RowVersionDefault) {
                throw ExceptionBuilder.SetFailed(column.ColumnName);
            }
            Row[column] = value;
        }

        /// <summary>
        /// Returns a <see cref="System.Data.DataView"/>
        /// for the child <see cref="System.Data.DataTable"/>
        /// with the specified <see cref="System.Data.DataRelation"/>.
        /// </summary>
        /// <param name="relation">Specified <see cref="System.Data.DataRelation"/>.</param>
        /// <exception cref="ArgumentException">null or mismatch between <paramref name="relation"/> and <see cref="System.Data.DataView.get_Table"/>.</exception>
        public DataView CreateChildView(DataRelation relation, bool followParent) {
            if (relation == null || relation.ParentKey.Table != DataView.Table) {
                throw ExceptionBuilder.CreateChildView();
            }
            RelatedView childView;
            if (!followParent) {
                int record = GetRecord();
                object[] values = relation.ParentKey.GetKeyValues(record);
                childView = new RelatedView(relation.ChildColumnsReference, values);
            }
            else {
                childView = new RelatedView(this, relation.ParentKey, relation.ChildColumnsReference);
            }
            childView.SetIndex("", DataViewRowState.CurrentRows, null); // finish construction via RelatedView.SetIndex
            childView.SetDataViewManager(DataView.DataViewManager);
            return childView;
        }


        public DataView CreateChildView(DataRelation relation) {
            return CreateChildView(relation, followParent: false);
        }


        /// <summary><see cref="CreateChildView(DataRelation)"/></summary>
        /// <param name="relationName">Specified <see cref="System.Data.DataRelation"/> name.</param>
        /// <exception cref="ArgumentException">Unmatched <paramref name="relationName"/>.</exception>
        public DataView CreateChildView(string relationName, bool followParent) {
            return CreateChildView(DataView.Table.ChildRelations[relationName], followParent);
        }

        public DataView CreateChildView(string relationName) {
            return CreateChildView(relationName, followParent: false);
        }

        public DataRow Row {
            get {
                return _row;
            }
        }

        public void BeginEdit() {
            delayBeginEdit = true;
        }

        public void CancelEdit() {
            DataRow tmpRow = Row;
            if (IsNew) {
                dataView.FinishAddNew(false);
            }
            else {
                tmpRow.CancelEdit();
            }
            delayBeginEdit = false;
        }

        public void EndEdit() {
            if (IsNew) {
                dataView.FinishAddNew(true);
            }
            else {
                Row.EndEdit();
            }
            delayBeginEdit = false;
        }

        public bool IsNew {
            get {
                return (_row == dataView.addNewRow);
            }
        }

        public bool IsEdit {
            get {
                return (
                    Row.HasVersion(DataRowVersion.Proposed) ||  // It was edited or
                    delayBeginEdit);                            // DataRowView.BegingEdit() was called, but not edited yet.
            }
        }

        public void Delete() {
            dataView.Delete(Row);
        }

        #region ICustomTypeDescriptor

        AttributeCollection ICustomTypeDescriptor.GetAttributes() {
            return new AttributeCollection((Attribute[])null);
        }

        string ICustomTypeDescriptor.GetClassName() {
            return null;
        }

        string ICustomTypeDescriptor.GetComponentName() {
            return null;
        }

        TypeConverter ICustomTypeDescriptor.GetConverter() {
            return null;
        }

        EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() {
            return null;
        }

        PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() {
            return null;
        }

        object ICustomTypeDescriptor.GetEditor(Type editorBaseType) {
            return null;
        }

        EventDescriptorCollection ICustomTypeDescriptor.GetEvents() {
            return new EventDescriptorCollection(null);
        }

        EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) {
            return new EventDescriptorCollection(null);
        }

        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() {
            return((ICustomTypeDescriptor)this).GetProperties(null);
        }

        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) {
            return (dataView.Table != null ? dataView.Table.GetPropertyDescriptorCollection(attributes) : zeroPropertyDescriptorCollection);
        }

        object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) {
            return this;
        }

        #endregion

        public event PropertyChangedEventHandler PropertyChanged {
            add {
                onPropertyChanged += value;
            }
            remove {
                onPropertyChanged -= value;
            }

        }

        internal void RaisePropertyChangedEvent (string propName){
            // Do not try catch, we would mask users bugs. if they throw we would catch
            if (onPropertyChanged != null) {
                onPropertyChanged (this, new PropertyChangedEventArgs(propName));
            }
        }
    }
}