using System;
using System.Data;
using System.Collections;

namespace BLToolkit.Mapping
{
    public class DataRowMapper : MapDataSourceDestinationBase
    {
        bool                    _createColumns;
        readonly DataRowVersion _version;

        public DataRowMapper(DataRow dataRow)
            : this(dataRow, DataRowVersion.Default)
        {
        }

        public DataRowMapper(DataRowView view)
            : this(view.Row, view.RowVersion)
        {
        }

        public DataRowMapper(DataRow dataRow, DataRowVersion version)
        {
            _version = version;

            Init(dataRow);
        }

        private void Init(DataRow dataRow)
        {
            if (_dataRow == null && dataRow != null)
                _createColumns = dataRow.Table.Columns.Count == 0;

            _dataRow = dataRow;
        }

        private DataRow _dataRow;
        public  DataRow  DataRow
        {
            get { return _dataRow; }
            set { Init(value);     }
        }

        #region IMapDataSource Members

        public override int Count
        {
            get { return _dataRow.Table.Columns.Count; }
        }

        public override Type GetFieldType(int index)
        {
            return index < _dataRow.Table.Columns.Count?
                _dataRow.Table.Columns[index].DataType: null;
        }

        public override string GetName(int index)
        {
            return _dataRow.Table.Columns[index].ColumnName;
        }

        public override object GetValue(object o, int index)
        {
            object value = _version == DataRowVersion.Default ? _dataRow[index] : _dataRow[index, _version];
            return value is DBNull? null: value;
        }

        public override object GetValue(object o, string name)
        {
            object value = _version == DataRowVersion.Default ? _dataRow[name] : _dataRow[name, _version];
            return value is DBNull? null: value;
        }

        public override bool IsNull(object o, int index)
        {
            if (_version == DataRowVersion.Default)
                return _dataRow.IsNull(index);

            DataColumn col = _dataRow.Table.Columns[index];

            return _dataRow.IsNull(col, _version);
        }

        #endregion

        #region IMapDataDestination Members

        private ArrayList _nameList;

        public override int GetOrdinal(string name)
        {
            if (_createColumns)
            {
                if (_nameList == null)
                    _nameList = new ArrayList();

                for (int i = 0; i < _nameList.Count; i++)
                    if (name == _nameList[i].ToString())
                        return i;

                return _nameList.Add(name);
            }

            return _dataRow.Table.Columns.IndexOf(name);
        }

        private void CreateColumn(int index, object value)
        {
            if (_dataRow.Table.Rows.Count > 1)
            {
                _createColumns = false;
            }
            else
            {
                DataColumnCollection cc   = _dataRow.Table.Columns;
                string               name = _nameList[index].ToString();

                DataColumn column = 
                    value == null || value is DBNull? cc.Add(name): cc.Add(name, value.GetType());

                if (cc.IndexOf(column) != index)
                    throw new MappingException(string.Format("Cant create data column '{0}'.", name));
            }
        }

        public override void SetValue(object o, int index, object value)
        {
            if (_createColumns)
                CreateColumn(index, value);

            if (value == null || value is DBNull)
            {
                _dataRow[index] = DBNull.Value;
            }
            else
            {
                DataColumn column = _dataRow.Table.Columns[index];

                if (column.DataType != value.GetType())
                {
                    if (column.DataType == typeof(Guid))
                    {
                        value = new Guid(value.ToString());
                    }
                    else
                    {
                        if (column.DataType != typeof(string))
                            value = Convert.ChangeType(value, column.DataType);
                    }
                }

                _dataRow[index] = value;
            }
        }

        public override void SetValue(object o, string name, object value)
        {
            if (_createColumns)
                CreateColumn(GetOrdinal(name), value);

            if (value == null || value is DBNull)
            {
                _dataRow[name] = DBNull.Value;
            }
            else
            {
                DataColumn dc = _dataRow.Table.Columns[name];

                if (dc.DataType != value.GetType())
                {
                    if (dc.DataType == typeof(Guid))
                    {
                        value = new Guid(value.ToString());
                    }
                    else
                    {
                        if (dc.DataType != typeof(string))
                            value = Convert.ChangeType(value, dc.DataType);
                    }
                }

                _dataRow[name] = value;
            }
        }

        #endregion
    }
}