using Dapper;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using VolPro.Core.Controllers.Basic;
using VolPro.Core.Dapper;
using VolPro.Core.DBManager;
using VolPro.Core.DbSqlSugar;
using VolPro.Core.EFDbContext;
using VolPro.Core.Filters;
using VolPro.Core.UserManager;
using VolPro.Core.Utilities;

namespace VolPro.Core.Generic
{

    public class GenericBaseService
    {
        public WebResponseContent WebResponse { get; set; }
        public GenericBaseService()
        {
            WebResponse = new WebResponseContent();
        }

        public int DbParamsCount
        {
            get
            {
                return DbRelativeCache.GetDbType(TableInfo.DBServer) == "MsSql" ? 2000 : 100000;
            }
        }
        private UserManager.TableInfo _tableInfo { get; set; }
        public UserManager.TableInfo TableInfo
        {
            get
            {
                if (_tableInfo != null) return _tableInfo;
                _tableInfo = TableColumnContext.TableInfo
                  .Where(x => x.TableName == GenericTableAsyncLocal.CurrentTableName)
                  .FirstOrDefault();
                if (_tableInfo == null) throw new Exception($" 未找到表【{GenericTableAsyncLocal.CurrentTableName}】 配置信息");
                if (string.IsNullOrEmpty(_tableInfo.DBServer))
                {
                    _tableInfo.DBServer = typeof(SysDbContext).Name;
                }
                return _tableInfo;
            }
        }

        public UserManager.TableInfo GetDetailTableInfo(string tableName = null)
        {
            if (string.IsNullOrEmpty(TableInfo.DetailName))
            {
                return null;
            }
            //主从表
            if (string.IsNullOrEmpty(tableName))
            {
                return TableColumnContext.TableInfo.Where(x => x.TableName == TableInfo.DetailName).FirstOrDefault();
            }
            //一对多
            return TableColumnContext.TableInfo.Where(x => x.TableName == tableName).FirstOrDefault();
        }

        public UserManager.TableInfo GetTableInfo(string tableName = null)
        {
            return TableColumnContext.TableInfo.Where(x => x.TableName == tableName).FirstOrDefault();
        }
        private BaseDbContext _dbContext { get; set; }
        public BaseDbContext DbContext
        {
            get
            {
                if (_dbContext != null) return _dbContext;
                string dbServer = _tableInfo.DBServer;
                var type = DbRelativeCache.GetDbContextType(dbServer);
                object dbObj = HttpContext.Current.RequestServices.GetService(type);
                _dbContext = (BaseDbContext)dbObj;
                return _dbContext;
            }
        }

        private List<TableColumnField> _columns { get; set; }
        public List<TableColumnField> Columns
        {
            get
            {
                if (_columns != null) return _columns;
                _columns = TableColumnContext.Data
                  .Where(x => x.TableName == GenericTableAsyncLocal.CurrentTableName)
                  .ToList();
                return _columns;
            }
        }

        /// <summary>
        /// 实际表字段
        /// </summary>
        private List<TableColumnField> _tableColumns { get; set; }
        public List<TableColumnField> TableColumns
        {
            get
            {
                if (_tableColumns != null) return _tableColumns;
                _tableColumns = Columns.Where(x => x.ReferenceField == 0).ToList();
                return _tableColumns;
            }
        }

        public List<TableColumnField> GetTableColumns(string table)
        {
            return TableColumnContext.Data
                  .Where(x => x.TableName == table)
                  .ToList();
        }

        private ISqlSugarClient _genericDbContext { get; set; }
        public ISqlSugarClient GenericDbContext
        {
            get
            {
                if (_genericDbContext == null)
                {
                    _genericDbContext = DbManger.GetSqlSugarClient(TableInfo.DBServer);
                }
                return _genericDbContext;
            }
        }
        public async Task<List<dynamic>> QueryListAsync(string sql, List<SugarParameter> parameters)
        {
            return await GenericDbContext.Ado.SqlQueryAsync<dynamic>(sql, parameters);
        }
        public async Task<object> ExecuteScalarAsync(string sql, List<SugarParameter> parameters)
        {
            return await GenericDbContext.Ado.GetScalarAsync(sql, parameters);
        }

        public async Task<int> ExcuteNonQueryAsync(string sql, object parameters)
        {
            return await GenericDbContext.Ado.ExecuteCommandAsync(sql, parameters);
        }

        public async Task BeginTranAsync()
        {
            await GenericDbContext.Ado.BeginTranAsync();
        }

        public async Task CommitTranAsync()
        {
            await GenericDbContext.Ado.CommitTranAsync();
        }

        public async Task RollbackTranAsync()
        {
            await GenericDbContext.Ado.RollbackTranAsync();
        }
    }
}