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

using BLToolkit.Aspects;
using BLToolkit.Data;
using BLToolkit.Mapping;
using BLToolkit.Properties;
using BLToolkit.Reflection.Extension;

namespace BLToolkit.DataAccess
{
    public abstract class DataAccessorBase
    {
        #region Constructors

        [System.Diagnostics.DebuggerStepThrough]
        protected DataAccessorBase()
        {
        }

        [System.Diagnostics.DebuggerStepThrough]
        protected DataAccessorBase(DbManager dbManager)
        {
            SetDbManager(dbManager, false);
        }

        [System.Diagnostics.DebuggerStepThrough]
        protected DataAccessorBase(DbManager dbManager, bool dispose)
        {
            SetDbManager(dbManager, dispose);
        }

        #endregion

        #region Public Members

        [NoInterception, System.Diagnostics.DebuggerStepThrough]
        public virtual DbManager GetDbManager()
        {
            return _dbManager ?? CreateDbManager();
        }

        [NoInterception]
        protected virtual DbManager CreateDbManager()
        {
            return new DbManager();
        }

        [NoInterception]
        public virtual void BeginTransaction()
        {
            if (_dbManager == null)
                throw new InvalidOperationException(Resources.DataAccessorBase_NoDbManager);

            _dbManager.BeginTransaction();
        }

        [NoInterception]
        public virtual void BeginTransaction(IsolationLevel il)
        {
            if (_dbManager == null)
                throw new InvalidOperationException(Resources.DataAccessorBase_NoDbManager);

            _dbManager.BeginTransaction(il);
        }

        [NoInterception]
        public virtual void CommitTransaction()
        {
            if (_dbManager == null)
                throw new InvalidOperationException(Resources.DataAccessorBase_NoDbManager);

            _dbManager.CommitTransaction();
        }

        [NoInterception]
        public virtual void RollbackTransaction()
        {
            if (_dbManager == null)
                throw new InvalidOperationException(Resources.DataAccessorBase_NoDbManager);

            _dbManager.RollbackTransaction();
        }

        private ExtensionList _extensions;
        public  ExtensionList  Extensions
        {
            get { return _extensions ?? (_extensions = MappingSchema.Extensions); }
            set { _extensions = value; }
        }

        private        bool _disposeDbManager = true;
        [NoInterception]
        public virtual bool  DisposeDbManager
        {
            get { return _disposeDbManager;  }
            set { _disposeDbManager = value; }
        }

        private MappingSchema _mappingSchema;
        public  MappingSchema  MappingSchema
        {
            get { return _mappingSchema ?? (_mappingSchema = _dbManager != null? _dbManager.MappingSchema: Map.DefaultSchema); }
            set { _mappingSchema = value; }
        }

        #endregion

        #region Protected Members

        private   DbManager _dbManager;
        protected DbManager  DbManager
        {
            get { return _dbManager; }
        }

        protected internal void SetDbManager(DbManager dbManager, bool dispose)
        {
            _dbManager        = dbManager;
            _disposeDbManager = dispose;
        }

        [NoInterception]
        protected virtual string GetDefaultSpName(string typeName, string actionName)
        {
            return typeName == null?
                actionName:
                string.Format("{0}_{1}", typeName, actionName);
        }

        private static readonly Hashtable _actionSproc = new Hashtable();

        [NoInterception]
        protected virtual string GetSpName(Type type, string actionName)
        {
            if (type == null)
                return GetDefaultSpName(null, actionName);

            string key       = type.FullName + "$" + actionName;
            string sprocName = (string)_actionSproc[key];

            if (sprocName == null)
            {
                object[] attrs = type.GetCustomAttributes(typeof(ActionSprocNameAttribute), true);

                foreach (ActionSprocNameAttribute attr in attrs)
                {
                    if (attr.ActionName == actionName)
                    {
                        sprocName = attr.ProcedureName;
                        break;
                    }
                }

                if (sprocName == null)
                    sprocName = GetDefaultSpName(GetTableName(type), actionName);

                _actionSproc[key] = sprocName;
            }

            return sprocName;
        }

        [NoInterception]
        protected virtual string GetDatabaseName(Type type)
        {
            bool isSet;
            return MappingSchema.MetadataProvider.GetDatabaseName(type, Extensions, out isSet);
        }

        [NoInterception]
        protected virtual string GetOwnerName(Type type)
        {
            bool isSet;
            return MappingSchema.MetadataProvider.GetOwnerName(type, Extensions, out isSet);
        }

        [NoInterception]
        protected virtual string GetTableName(Type type)
        {
            bool isSet;
            return MappingSchema.MetadataProvider.GetTableName(type, Extensions, out isSet);
        }

        [NoInterception]
        protected virtual void Dispose(DbManager dbManager)
        {
            if (dbManager != null && DisposeDbManager)
                dbManager.Dispose();
        }

        #endregion
    }
}