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

namespace System.Data.Common {

    using System;
    using System.Collections;
    using System.ComponentModel;
    using System.Data;
    using System.IO;
    using System.Threading.Tasks;
    using System.Threading;
    
    public abstract class DbDataReader : MarshalByRefObject, IDataReader, IEnumerable { // V1.2.3300    
        protected DbDataReader() : base() {
        }
        
        abstract public int Depth {
            get;
        }
    
        abstract public int FieldCount { 
            get;
        }
        
        abstract public bool HasRows {
            get;
        }
        
        abstract public bool IsClosed {
            get;
        }
    
        abstract public int RecordsAffected {
            get;
        }
        
        virtual public int VisibleFieldCount { 
            // NOTE: This is virtual because not all providers may choose to support
            //       this property, since it was added in Whidbey
            get {
                return FieldCount;
            }
        }
        
        abstract public object this [ int ordinal ] {
            get;
        }
        
        abstract public object this [ string name ] {
            get;
        }

        virtual public void Close()
        {
        }

        [
        EditorBrowsableAttribute(EditorBrowsableState.Never)
        ]
        public void Dispose() {
            Dispose(true);
        }
    
        protected virtual void Dispose(bool disposing) {
            if (disposing) {
                Close();
            }
        }

        abstract public string GetDataTypeName(int ordinal);

        [
        EditorBrowsableAttribute(EditorBrowsableState.Never)
        ]
        abstract public IEnumerator GetEnumerator();
        
        abstract public Type GetFieldType(int ordinal);
          
        abstract public string GetName(int ordinal);
        
        abstract public int GetOrdinal(string name);

        virtual public DataTable GetSchemaTable()
        {
            throw new NotSupportedException();
        }
        
        abstract public bool GetBoolean(int ordinal);
        
        abstract public byte GetByte(int ordinal);
        
        abstract public long GetBytes(int ordinal, long dataOffset, byte[] buffer, int bufferOffset, int length);
        
        abstract public char GetChar(int ordinal);
        
        abstract public long GetChars(int ordinal, long dataOffset, char[] buffer, int bufferOffset, int length);
        
        [
        EditorBrowsableAttribute(EditorBrowsableState.Never)
        ]
        public DbDataReader GetData(int ordinal) {
            return GetDbDataReader(ordinal);
        }
        
        IDataReader IDataRecord.GetData(int ordinal) {
            return GetDbDataReader(ordinal);
        }
        
        virtual protected DbDataReader GetDbDataReader(int ordinal) {
            // NOTE: This method is virtual because we're required to implement
            //       it however most providers won't support it. Only the OLE DB 
            //       provider supports it right now, and they can override it.
            throw ADP.NotSupported();
        }
        
        abstract public DateTime GetDateTime(int ordinal);
        
        abstract public Decimal GetDecimal(int ordinal);
        
        abstract public double GetDouble(int ordinal);
        
        abstract public float GetFloat(int ordinal);
        
        abstract public Guid GetGuid(int ordinal);
        
        abstract public Int16 GetInt16(int ordinal);
        
        abstract public Int32 GetInt32(int ordinal);
        
        abstract public Int64 GetInt64(int ordinal);
        
        [
        EditorBrowsableAttribute(EditorBrowsableState.Never)
        ]
        virtual public Type GetProviderSpecificFieldType(int ordinal) {
            // NOTE: This is virtual because not all providers may choose to support
            //       this method, since it was added in Whidbey.
            return GetFieldType(ordinal);
        }
        
        [
        EditorBrowsableAttribute(EditorBrowsableState.Never)
        ]
        virtual public Object GetProviderSpecificValue(int ordinal) {
            // NOTE: This is virtual because not all providers may choose to support
            //       this method, since it was added in Whidbey
            return GetValue(ordinal);
        }
        
        [
        EditorBrowsableAttribute(EditorBrowsableState.Never)
        ]
        virtual public int GetProviderSpecificValues(object[] values) {
            // NOTE: This is virtual because not all providers may choose to support
            //       this method, since it was added in Whidbey
            return GetValues(values);
        }

        abstract public String GetString(int ordinal);

        virtual public Stream GetStream(int ordinal) {
            using (MemoryStream bufferStream = new MemoryStream())
            {
                long bytesRead = 0;
                long bytesReadTotal = 0;
                byte[] buffer = new byte[4096];
                do {
                    bytesRead = GetBytes(ordinal, bytesReadTotal, buffer, 0, buffer.Length);
                    bufferStream.Write(buffer, 0, (int)bytesRead);
                    bytesReadTotal += bytesRead;
                } while (bytesRead > 0);
                
                return new MemoryStream(bufferStream.ToArray(), false);
            }
        }

        virtual public TextReader GetTextReader(int ordinal) {
            if (IsDBNull(ordinal)) {
                return new StringReader(String.Empty);
            }
            else {
                return new StringReader(GetString(ordinal));
            }
        }
        
        abstract public Object GetValue(int ordinal);

        virtual public T GetFieldValue<T>(int ordinal) {
            return (T)GetValue(ordinal);
        }

        public Task<T> GetFieldValueAsync<T>(int ordinal) {
            return GetFieldValueAsync<T>(ordinal, CancellationToken.None);
        }

        virtual public Task<T> GetFieldValueAsync<T>(int ordinal, CancellationToken cancellationToken) {
            if (cancellationToken.IsCancellationRequested) {
                return ADP.CreatedTaskWithCancellation<T>();
            }
            else {
                try {
                    return Task.FromResult<T>(GetFieldValue<T>(ordinal));
                }
                catch (Exception e) {
                    return ADP.CreatedTaskWithException<T>(e);
                }
            }
        }
        
        abstract public int GetValues(object[] values);
        
        abstract public bool IsDBNull(int ordinal);

        public Task<bool> IsDBNullAsync(int ordinal) {
            return IsDBNullAsync(ordinal, CancellationToken.None);
        }

        virtual public Task<bool> IsDBNullAsync(int ordinal, CancellationToken cancellationToken) {
            if (cancellationToken.IsCancellationRequested) {
                return ADP.CreatedTaskWithCancellation<bool>();
            }
            else {
                try {
                    return IsDBNull(ordinal) ? ADP.TrueTask : ADP.FalseTask;
                }
                catch (Exception e) {
                    return ADP.CreatedTaskWithException<bool>(e);
                }
            }
        }
        
        abstract public bool NextResult();
    
        abstract public bool Read();

        public Task<bool> ReadAsync() {
            return ReadAsync(CancellationToken.None);
        }

        virtual public Task<bool> ReadAsync(CancellationToken cancellationToken) {
            if (cancellationToken.IsCancellationRequested) {
                return ADP.CreatedTaskWithCancellation<bool>();
            }
            else {
                try {
                    return Read() ? ADP.TrueTask : ADP.FalseTask;
                }
                catch (Exception e) {
                    return ADP.CreatedTaskWithException<bool>(e);
                }
            }
        }
        
        public Task<bool> NextResultAsync() {
            return NextResultAsync(CancellationToken.None);
        }

        virtual public Task<bool> NextResultAsync(CancellationToken cancellationToken) {
            if (cancellationToken.IsCancellationRequested) {
                return ADP.CreatedTaskWithCancellation<bool>();
            }
            else {
                try {
                    return NextResult() ? ADP.TrueTask : ADP.FalseTask;
                }
                catch (Exception e) {
                    return ADP.CreatedTaskWithException<bool>(e);
                }
            }
        }
    }

}