using SqlSugar;
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using SHJX.Service.Common.ReadXML;

namespace SHJX.Service.Dao
{
    public class DataManagerImp
    {
        /// <summary>
        /// 数据库连接
        /// </summary>
        protected SqlSugarClient Db;

        /// <summary>
        /// 配置文件读取
        /// </summary>
        private ReadConfigUtil _config;

        /// <summary>
        /// 初始化数据
        /// </summary>
        protected void InitData(ReadConfigUtil config)
        {
            _config = config;
            GetSqlSugarClient();
        }

        /// <summary>
        /// 创建SqlSugarClient
        /// </summary>
        /// <returns>SqlSugarClient连接对象</returns>
        private void GetSqlSugarClient()
        {
            //创建数据库对象
            Db = new SqlSugarClient(new ConnectionConfig()
            {
                ConnectionString = _config.ConnStr, //连接符字串
                DbType = DbType.MySql, //数据库类型
                IsAutoCloseConnection = true,
                InitKeyType = InitKeyType.Attribute //从特性读取主键自增信息
            });
            /* //添加Sql打印事件(可删掉)
             Db.Aop.OnLogExecuting = (sql, pars) => logger.WarnFormat("{0} {1}",
            sql,Db.Utilities.SerializeObject(pars.ToDictionary(item => item.ParameterName,item => item.Value)));*/
        }

        /// <summary>
        /// 查询全部数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public IEnumerable<T> Query<T>() where T : class =>
            Db.Queryable<T>().ToList();

        /// <summary>
        /// 根据条件表达式删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        /// <returns></returns>
        public int Delete<T>(Func<T> func) where T : class, new() =>
            Db.Deleteable<T>().Where(func.Invoke()).ExecuteCommand();

        /// <summary>
        /// 根据实体删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public int Delete<T>(T t) where T : class, new() =>
            Db.Deleteable<T>().Where(t).ExecuteCommand();

        /// <summary>
        /// 批量删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="lists"></param>
        /// <returns></returns>
        public int Delete<T>(List<T> lists) where T : class, new() =>
            Db.Deleteable<T>().Where(lists).ExecuteCommand();

        /// <summary>
        /// 根据主键删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="id"></param>
        /// <returns></returns>
        public int Delete<T>(int id) where T : class, new() =>
            Db.Deleteable<T>().In(id).ExecuteCommand();

        /// <summary>
        /// 根据条件表达式删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        /// <returns></returns>
        public Task<int> DeleteAsync<T>(Func<T> func) where T : class, new() =>
            Db.Deleteable<T>().Where(func.Invoke()).ExecuteCommandAsync();

        /// <summary>
        /// 根据实体删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public Task<int> DeleteAsync<T>(T t) where T : class, new() =>
            Db.Deleteable<T>().Where(t).ExecuteCommandAsync();

        /// <summary>
        /// 删除集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="lists"></param>
        /// <returns></returns>
        public Task<int> DeleteAsync<T>(List<T> lists) where T : class, new() =>
            Db.Deleteable<T>().Where(lists).ExecuteCommandAsync();

        /// <summary>
        /// 根据主键删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="id"></param>
        /// <returns></returns>
        public Task<int> DeleteAsync<T>(int id) where T : class, new() =>
            Db.Deleteable<T>().In(id).ExecuteCommandAsync();

        /// <summary>
        /// 根据实体插入
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public int Insert<T>(T t) where T : class, new() =>
            Db.Insertable(t).ExecuteCommand();

        /// <summary>
        /// 批量插入
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public int Insert<T>(List<T> t) where T : class, new() =>
            Db.Insertable(t).ExecuteCommand();

        /// <summary>
        /// 异步插入
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public Task<int> InsertAsync<T>(T t) where T : class, new() =>
            Db.Insertable(t).ExecuteCommandAsync();

        /// <summary>
        /// 单条数据更新
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public int Update<T>(T t) where T : class, new() =>
            Db.Updateable(t).ExecuteCommand();

        //IUpdateExpressions<T> Update<T>() where T : class;
        /// <summary>
        /// 多条数据同时更新
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="lists"></param>
        /// <returns></returns>
        public int Update<T>(List<T> lists) where T : class, new() =>
            Db.Updateable(lists).ExecuteCommand();

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="isUpdateParams">true:只更新指定字段 false:不更新指定字段</param>
        /// <param name="columns"></param>
        /// <returns></returns>
        public int Update<T>(T t, bool isUpdateParams, params string[] columns) where T : class, new() =>
            isUpdateParams
                ? Db.Updateable(t).UpdateColumns(columns).ExecuteCommand()
                : Db.Updateable(t).IgnoreColumns(columns).ExecuteCommand();

        /// <summary>
        /// 单条数据更新
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public Task<int> UpdateAsycn<T>(T t) where T : class, new() =>
            Db.Updateable(t).ExecuteCommandAsync();

        /// <summary>
        /// 多条数据同时更新
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="lists"></param>
        /// <returns></returns>
        public Task<int> UpdateAsycn<T>(List<T> lists) where T : class, new() =>
            Db.Updateable(lists).ExecuteCommandAsync();

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="isUpdateParams">true:只更新指定字段 false:不更新指定字段</param>
        /// <param name="columns"></param>
        /// <returns></returns>
        public Task<int> UpdateAsycn<T>(T t, bool isUpdateParams, params string[] columns) where T : class, new() =>
            isUpdateParams
                ? Db.Updateable(t).UpdateColumns(columns).ExecuteCommandAsync()
                : Db.Updateable(t).IgnoreColumns(columns).ExecuteCommandAsync();
    }
}