using Rhea.Common;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;
using System.Text;
using System.Threading.Tasks;
using Tiger.Model;

namespace Tiger.IBusiness
{
    /// <summary>
    /// 数据库操作基础类
    /// </summary>
    public interface IDbBase
    {
        #region 添加操作
        /// <summary>
        /// 把单个实体往数据库添加一行数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity">实体</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<T>> AddAsync<T>(T entity, bool isAsync = true) where T : class, new();

        /// <summary>
        /// 把实体List往数据库批量添加数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list">实体List</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<T>> AddListAsync<T>(List<T> list, bool isAsync = true) where T : class, new();
        #endregion

        #region 保存操作
        /// <summary>
        /// 把单个实体往数据库保存一行数据，如果存在就更新，不存在就插入
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity">实体</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<T>> SaveAsync<T>(T entity, bool isAsync = true) where T : class, new();

        /// <summary>
        /// 把实体List往数据库批量保存数据，如果存在就更新，不存在就插入
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list">实体List</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<T>> SaveListAsync<T>(List<T> list, bool isAsync = true) where T : class, new();

        /// <summary>
        /// 把单个实体往数据库保存一行数据，如果存在就更新，不存在就插入
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity">实体</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<T>> StorageableAsync<T>(T entity, bool isAsync = true) where T : class, new();

        /// <summary>
        /// 把实体List往数据库批量保存数据，如果存在就更新，不存在就插入
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list">实体List</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<T>> StorageableListAsync<T>(List<T> list, bool isAsync = true) where T : class, new();
        #endregion

        #region 修改操作
        /// <summary>
        /// 从数据库中修改单个实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity">实体</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> UpdateAsync<T>(T entity, bool isAsync = true) where T : class, new();

        /// <summary>
        /// 根据实体List在数据库批量修改数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list">实体List</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> UpdateAsync<T>(List<T> list, bool isAsync = true) where T : class, new();

        /// <summary>
        /// 按UpdaterAble&lt;T>对象从数据库中修改多个实体的某些字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="updater">实体List</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> UpdateAsync<T>(UpdateAble<T> updater, bool isAsync = true) where T : class, new();
        #endregion

        #region 删除操作
        /// <summary>
        /// 从数据库中删除多个实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="primaryKeys">实体的主键ID数组</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> DeleteAsync<T>(T newEntity, string[] primaryKeys, bool isAsync = true) where T : class, new();

        /// <summary>
        /// 从数据库中删除单个实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity">实体</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> DeleteAsync<T>(T entity, bool isAsync = true) where T : class, new();

        /// <summary>
        /// 从数据库中删除实体List
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list">实体List</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> DeleteAsync<T>(List<T> list, bool isAsync = true) where T : class, new();

        /// <summary>
        /// 根据Where语句删除满足条件的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="where">Where语句</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> DeleteAsync<T>(T newEntity, string where, bool isAsync = true) where T : class, new();
        #endregion

        #region 查询操作
        /// <summary>
        /// 从数据库中查询实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<List<T>>> QueryAsync<T>(T newEntity, bool isAsync = true, bool needInclude = false);

        /// <summary>
        /// 根据Where语句从数据库中查询实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="where">Where语句</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<List<T>>> QueryAsync<T>(T newEntity, string where, bool isAsync = true, bool needInclude = false) where T : class, new();

        /// <summary>
        /// 按PageAble&lt;T>对象返回实体当前Page的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="page">分页的参数实体</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<PageAble<T>>> QueryAsync<T>(PageAble<T> page, bool isAsync = true, bool needInclude = false);

        /// <summary>
        /// 分页直接返回PageAble&lt;T>
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="page"></param>
        /// <param name="isAsync"></param>
        /// <returns></returns>
        public Task<ApiAction<PageAble<T>>> QueryPageAsync<T>(PageAble<T> page, bool isAsync = true, bool needInclude = false);

        /// <summary>
        /// 按QueryAble&lt;T>对象从数据库查询满足条件的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="query">QueryAble的参数实体</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<QueryAble<T>>> QueryAsync<T>(QueryAble<T> query, bool isAsync = true, bool needInclude = false);

        /// <summary>
        /// 根据SQL语句从数据库中查询实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="sqlcmd">SQL语句</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<List<T>>> QuerySqlAsync<T>(T newEntity, string sqlcmd, bool isAsync = true, bool needInclude = false) where T : class, new();

        /// <summary>
        /// 根据SQL语句从数据库中查询并按PageAble&lt;T>对象返回当前Page的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="page">分页的参数实体</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<PageAble<T>>> QuerySqlAsync<T>(PageAble<T> page, bool isAsync = true, bool needInclude = false) where T : class, new();

        /// <summary>
        /// 从数据库中查询实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="options">授权查询配置项</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<List<T>>> QueryByAuthAsync<T>(T newEntity, AuthOption options, bool isAsync = true, bool needInclude = false) where T : iTableHasAuth, new();

        /// <summary>
        /// 根据Where语句从数据库中查询实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="where">Where语句</param>
        /// <param name="options">授权查询配置项</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<List<T>>> QueryByAuthAsync<T>(T newEntity, string where, AuthOption options, bool isAsync = true, bool needInclude = false) where T : iTableHasAuth, new();

        /// <summary>
        /// 按PageAble&lt;T>对象返回实体当前Page的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="page">分页的参数实体</param>
        /// <param name="options">授权查询配置项</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<PageAble<T>>> QueryByAuthAsync<T>(PageAble<T> page, AuthOption options, bool isAsync = true, bool needInclude = false) where T : iTableHasAuth, new();

        /// <summary>
        /// 分页直接返回PageAble&lt;T>
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="page"></param>
        /// <param name="options">授权查询配置项</param>
        /// <param name="isAsync"></param>
        /// <returns></returns>
        public Task<ApiAction<PageAble<T>>> QueryByAuthPageAsync<T>(PageAble<T> page, AuthOption options, bool isAsync = true, bool needInclude = false) where T : iTableHasAuth, new();

        /// <summary>
        /// 按QueryAble&lt;T>对象从数据库查询满足条件的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="query">QueryAble的参数实体</param>
        /// <param name="options">授权查询配置项</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction<QueryAble<T>>> QueryByAuthAsync<T>(QueryAble<T> query, AuthOption options, bool isAsync = true, bool needInclude = false) where T : iTableHasAuth, new();

        #endregion

        #region 查询 Count
        /// <summary>
        /// 根据Where语句查询满足条件的实体的Count数量
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="where">Where语句</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> CountAsync<T>(T newEntity, string where, bool isAsync = true);

        /// <summary>
        /// 根据Where语句查询满足条件的实体的Count数量
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="where">Where语句</param>
        /// <param name="options">授权查询配置项</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> CountByAuthAsync<T>(T newEntity, string where, AuthOption options, bool isAsync = true) where T : iTableHasAuth, new();
        #endregion

        #region 查询 Exist
        /// <summary>
        /// 根据Where语句查询满足条件的Data实体是否存在
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="where">Where语句</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> IsExistAsync<T>(T newEntity, string where, bool isAsync = true);

        /// <summary>
        /// 根据Where语句查询满足条件的Data实体是否存在
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="newEntity">固定用法：通过ApiAction.NewDataEntity()创建ApiAction中指定类型对象</param>
        /// <param name="where">Where语句</param>
        /// <param name="options">授权查询配置项</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> IsExistByAuthAsync<T>(T newEntity, string where, AuthOption options, bool isAsync = true) where T : iTableHasAuth, new();
        #endregion

        #region 执行SQL
        /// <summary>
        /// 执行SQL语句返回影响行数
        /// </summary>
        /// <param name="sqlcmd">要执行的SQL语句</param>
        /// <param name="parameters">SQL语句的参数</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> ExecuteSqlCommandAsync(string sqlcmd, List<SugarParameter> parameters, bool isAsync = true);

        /// <summary>
        /// 执行SQL语句返回影响行数
        /// </summary>
        /// <param name="sqlcmd">要执行的SQL语句</param>
        /// <param name="parameters">SQL语句的参数</param>
        /// <param name="isAsync">是否以异步方式执行</param>
        /// <returns></returns>
        public Task<ApiAction> ExecuteSqlCommandAsync(string sqlcmd, bool isAsync = true, params SugarParameter[] parameters);

        /// <summary>
        /// 异步方式执行SQL语句返回影响行数
        /// </summary>
        /// <param name="sqlcmd">要执行的SQL语句</param>
        /// <param name="parameters">SQL语句的参数</param>
        /// <returns></returns>
        public Task<ApiAction> ExecuteSqlCommandAsync(string sqlcmd, params SugarParameter[] parameters);
        #endregion

        #region 先删除后新增
        public Task<ApiAction> AddAfterDeleteAsync<T>(QueryAble<T> query) where T : class, new();

        #endregion

    }
}