using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace MyCode.Project.Domain.Repositories
{
    public interface IRepository
    {
        /// <summary>
        /// 按字段批量修改一组对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="updateObjs"></param>
        /// <param name="columns"></param>
        int Update<T>(List<T> updateObjs, Expression<Func<T, object>> columns) where T : class, new();

        /// <summary>
        /// 增加允许跨仓储调用修改方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="updateObjs"></param>
        /// <param name="columns"></param>
        void UpdateQueue<T>(Expression<Func<T, T>> columns, Expression<Func<T, bool>> whereExpression) where T : class, new();

        /// <summary>
        /// 得到一个更加灵活的查询对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="T2"></typeparam>
        /// <typeparam name="T3"></typeparam>
        /// <typeparam name="T4"></typeparam>
        /// <param name="joinExpression"></param>
        /// <returns></returns>
        ISugarQueryable<T, T2, T3, T4> Queryable<T, T2, T3, T4>(Expression<Func<T, T2, T3, T4, object[]>> joinExpression);

        /// <summary>
        /// 得到一个更加灵活的查询对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="T2"></typeparam>
        /// <typeparam name="T3"></typeparam>
        /// <typeparam name="T4"></typeparam>
        /// <typeparam name="T5"></typeparam>
        /// <param name="joinExpression"></param>
        /// <returns></returns>
        ISugarQueryable<T, T2, T3, T4, T5> Queryable<T, T2, T3, T4, T5>(Expression<Func<T, T2, T3, T4, T5, object[]>> joinExpression);

        /// <summary>
        /// 按照列添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="columns"></param>
        void AddQueue<T>(T t, Expression<Func<T, object>> columns) where T : class, new();

        /// <summary>
        /// 加入数据库队列
        /// </summary>
        /// <param name="instance"></param>
        /// <param name="tablename"></param>
        void AddQueue<T>(T instance, string tablename = null) where T : class, new();

        /// <summary>
        /// 得到当前的sql对象hashcode
        /// </summary>
        /// <returns></returns>
        int GetSqlHashCode();

        /// <summary>
        /// 修改实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        void Update<T>(T t) where T : class, new();

        /// <summary>
        /// 根据表达式删除
        /// </summary>
        /// <param name="whereExpression"></param>
        int Delete<T>(Expression<Func<T, bool>> whereExpression) where T : class, new();

        /// <summary>
        /// Union表操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="queryables"></param>
        /// <returns></returns>
        ISugarQueryable<T> UnionAll<T>(params ISugarQueryable<T>[] queryables) where T : class, new();

        /// <summary>
        /// 得到一个更加灵活的查询对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="shortName"></param>
        /// <returns></returns>
        ISugarQueryable<T> Queryable<T>(string shortName = "") where T : class, new();

        /// <summary>
        /// 一起执行提交
        /// </summary>
        int SaveQueue();

        /// <summary>
        /// 按照列添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="columns"></param>
        void AddQueue<T>(T t) where T : class, new();

        /// <summary>
        /// 按照列添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        void Add<T>(T t) where T : class, new();

        /// <summary>
        /// 批量添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
       void Add<T>(List<T> t) where T : class, new();

        /// <summary>
        /// 得到一个更加灵活的查询对象
        /// </summary>
        /// <returns></returns>
        ISugarQueryable<T, T2> Queryable<T, T2>(Expression<Func<T, T2, object[]>> joinExpression);

        /// <summary>
        /// 批量添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        void AddQueue<T>(List<T> list) where T : class, new();

        /// <summary>
        /// 按字段修改，满足条件的数据，批量修改的补充。
        /// 例子：Update(it => new WorkProcess { Remark = "测试批量修改",SystemType = 0 },p => p.WorkProcessId ==Guid.Parse("7BDDBBD3-B1CD-4C25-93BA-D7BF22032108"));
        /// </summary>
        /// <param name="columns">要修改的列</param>
        /// <param name="whereExpression">要修改的条件</param>
        int Update<T>(Expression<Func<T, T>> columns, Expression<Func<T, bool>> whereExpression) where T : class, new();

        /// <summary>
        /// 添加修改的队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        void UpdateQueue<T>(T t) where T : class, new();

        /// <summary>
        /// 得到数量
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="predicate"></param>
        /// <returns></returns>
        int Count<T>(Expression<Func<T, bool>> predicate);

        /// <summary>
        /// 得到一个更加灵活的查询对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="T2"></typeparam>
        /// <typeparam name="T3"></typeparam>
        /// <param name="joinExpression"></param>
        /// <returns></returns>
        ISugarQueryable<T, T2, T3> Queryable<T, T2, T3>(Expression<Func<T, T2, T3, object[]>> joinExpression);

        /// <summary>
        /// 判断是否存在
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="whereExpression"></param>
        /// <returns></returns>
        bool IsExist<T>(Expression<Func<T, bool>> whereExpression);

        /// <summary>
        /// 添加一个委托的方式执行事务
        /// </summary>
        /// <param name="action"></param>
        void UseTran(Action action);

        /// <summary>
        /// 按字段批量修改一组对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="updateObjs"></param>
        /// <param name="columns"></param>
        int Update<T>(List<T> updateObjs) where T : class, new();

        /// <summary>
        /// 按字段批量修改一组对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="updateObjs"></param>
        /// <param name="columns"></param>
        void UpdateQueue<T>(List<T> updateObjs, Expression<Func<T, object>> columns) where T : class, new();

        /// <summary>
        /// 根据表达式删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="whereExpression"></param>
        void DeleteQueue<T>(Expression<Func<T, bool>> whereExpression) where T : class, new();

        /// <summary>
        /// 清空表数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        void TruncateTable<T>() where T : class, new();

        /// <summary>
        /// 清除数据库队列
        /// </summary>
        void ClearQueue();

        /// <summary>
        /// 修改的队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        void UpdateQueue<T>(List<T> list) where T:class,new();

        /// <summary>
        /// 禁止参数转换成NVarchar
        /// </summary>
        void DisableNVarchar();

        /// <summary>
        /// 启用参数转换成NVarchar
        /// </summary>
        void EnableNVarchar();
    }
}