using System.Linq.Expressions;
using SJZY.Expand.ABP.Core.PublicMethords;
using SJZY.Track.Domain.Aggregates.TrackContentAggregate;
using SJZY.Track.Domain.Aggregates.TrackFlagAggregate;
using SJZY.Track.Domain.Aggregates.TrackNodeAggregate;
using SJZY.Track.Domain.Aggregates.TrackStatusAggregate;
using SJZY.Track.Domain.Aggregates.TrackTemplateAggregate;
using SJZY.Track.Domain.Dtos.TrackTemplate;
using SJZY.Track.Domain.Enums;
using SJZY.Track.Domain.VEntities;
using SJZY.Expand.ABP.Core.SqlSugar.Tools;

namespace SJZY.Track.Repository.Repositories;

public class TrackTemplateRepository : BasicRepository<TrackTemplateEntity>, ITrackTemplateRepository, IScopedDependency
{
    /// <summary>
    /// 获取轨迹模版明细
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public async Task<GetTrackTemplateDetailVO?> GetDetailAsync(int id)
    {
        var detail = await Context.Queryable<TrackTemplateEntity>()
            .LeftJoin<VSystemEntity>((a, b) => a.SubSystemId == b.Id && b.IsDeleted == false)
            .Where((a, b) => a.Id == id)
            .Select((a, b) => new GetTrackTemplateDetailVO
            {
                Id = a.Id,
                Code = a.Code,
                Name = a.Name,
                SubSystemId = a.SubSystemId,
                SubSystem = b.CnName,
                CustomerId = a.CustomerId,
                CategoryId = a.CategoryId,
            }).FirstAsync();

        return detail;
    }

    /// <summary>
    /// 分页获取轨迹模版
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<UnifyPageResultDto<GetTrackTemplateListVO>> GetPageTrackTemplate(GetPageTrackTemplateVO input)
    {
        var pagedList = await Context.Queryable<TrackTemplateEntity>()
            .LeftJoin<VSystemEntity>((a, b) => a.SubSystemId == b.Id && b.IsDeleted == false)
            .WhereIF(input.SubSystemId > 0, (a, b) => a.SubSystemId == input.SubSystemId)
            .WhereIF(!input.Keywords.IsNullOrWhiteSpace(),
                (a, b) => a.Name.Contains(input.Keywords!) || a.Code.Contains(input.Keywords!))
            .OrderByIF(input.SelectIds.IsNullOrEmpty(), (a, b) => a.CreateTime, OrderByType.Desc)
            .OrderByIF(!input.SelectIds.IsNullOrEmpty(),
                (a, b) => SqlFunc.IIF(input.SelectIds!.Contains(a.Id), SqlFunc.DateAdd(SqlFunc.GetDate(), 1),
                    a.CreateTime), OrderByType.Desc)
            .Select((a, b) => new GetTrackTemplateListVO
            {
                Id = a.Id,
                Code = a.Code,
                CreateTime = a.CreateTime,
                Name = a.Name,
                SubSystem = b.CnName,
                SubSystemId = b.Id
            })
            .ToPagedListAsync(input.PageIndex, input.PageSize);
        //.OrderByIF(input.TrackTemplateId > 0,
        //    (a, b) => SqlFunc.IIF(a.Id == input.TrackTemplateId, SqlFunc.DateAdd(SqlFunc.GetDate(), 1),
        //a.CreateTime), OrderByType.Desc)
        return pagedList;
    }

    /// <inheritdoc/>
    public async Task<UnifyPageResultDto<GetTrackTemplateContentPageOutputVO>> GetContentPageAsync(
        GetTrackTemplateContentPageInputVO input)
    {
        return await Context.Queryable<TrackTemplateContentEntity>()
            .InnerJoin<TrackContentEntity>((templateContent, trackContent) =>
                templateContent.TrackContentId == trackContent.Id && !trackContent.IsDeleted)
            .LeftJoin<TrackStatusEntity>((templateContent, trackContent, trackStatus) =>
                trackContent.TrackStatusId == trackStatus.Id && !trackStatus.IsDeleted)
            .LeftJoin<VEnumValueInfoEntity>((templateContent, trackContent, trackStatus, enumValue) =>
                enumValue.Property == EnumPropertyEnums.节点.GetDescription() && trackStatus.Node == enumValue.Enumkey &&
                !enumValue.IsDeleted)
            .LeftJoin<VUserEntity>((templateContent, trackContent, trackStatus, enumValue, createUser) =>
                templateContent.CreateUserId == createUser.Id && !createUser.IsDeleted)
            .LeftJoin<VUserEntity>(
                (templateContent, trackContent, trackStatus, enumValue, createUser, updateUser) =>
                    templateContent.UpdateUserId == updateUser.Id && !updateUser.IsDeleted)
            .Filter(null, true)
            .Where(templateContent => input.TrackTemplateIds.Contains(templateContent.TrackTemplateId) &&
                                      !templateContent.IsDeleted)
            .Select((templateContent, trackContent, trackStatus, enumValue, createUser, updateUser) =>
                new GetTrackTemplateContentPageOutputVO
                {
                    Id = templateContent.Id,
                    TrackStatus = trackStatus.Status,
                    Node = enumValue.Disp,
                    TrackFlag = SqlFunc.Subqueryable<TrackFlagEntity>()
                        .Where(x => SqlFunc.SplitIn(trackContent.TrackFlagId, x.Id.ToString()))
                        .SelectStringJoin(x => x.Name, ","),
                    CreateTime = templateContent.CreateTime,
                    CreateUser = createUser.Name,
                    UpdateTime = templateContent.UpdateTime,
                    UpdateUser = updateUser.Name
                }, true)
            .OrderBy(templateContent => templateContent.Sort)
            .ToPagedListAsync(input.PageIndex, input.PageSize);
    }

    /// <inheritdoc/>
    public async Task<GetTrackTemplateContentDetailOutputVo> GetContentDetailAsync(int id)
    {
        return await Context.Queryable<TrackTemplateContentEntity>()
            .InnerJoin<TrackContentEntity>((templateContent, trackContent) =>
                templateContent.TrackContentId == trackContent.Id && !trackContent.IsDeleted)
            .LeftJoin<TrackStatusEntity>((templateContent, trackContent, trackStatus) =>
                trackContent.TrackStatusId == trackStatus.Id && !trackStatus.IsDeleted)
            .Filter(null, true)
            .Where(templateContent => templateContent.Id == id && !templateContent.IsDeleted)
            .Select(
                (templateContent, trackContent, trackStatus) => new GetTrackTemplateContentDetailOutputVo
                {
                    Id = templateContent.Id,
                    TrackContent = trackContent.Code + "-" + trackContent.Content,
                    TrackStatus = trackStatus.Status
                }, true)
            .SingleAsync();
    }

    /// <inheritdoc/>
    public async Task<bool> IsContentAnyAsync(Expression<Func<TrackTemplateContentEntity, bool>> whereExpression)
    {
        return await Context.Queryable<TrackTemplateContentEntity>().Where(whereExpression).AnyAsync();
    }

    /// <inheritdoc/>
    public async Task<bool> InsertContentAsync(TrackTemplateContentEntity insertObj)
    {
        return await Context.Insertable(insertObj).ExecuteCommandAsync() > 0;
    }

    /// <inheritdoc/>
    public async Task<TrackTemplateContentEntity> GetContentByIdAsync(int id)
    {
        return await Context.Queryable<TrackTemplateContentEntity>().InSingleAsync(id);
    }

    /// <inheritdoc/>
    public async Task<bool> UpdateContentAsync(TrackTemplateContentEntity updateObj)
    {
        return await Context.Updateable(updateObj).ExecuteCommandHasChangeAsync();
    }

    /// <inheritdoc/>
    public async Task<bool> SoftDeleteContentAsync(int id)
    {
        return await Context.Updateable<TrackTemplateContentEntity>()
            .Where(x => x.Id == id)
            .SetColumns(nameof(ISoftDeleteBasicEntity.IsDeleted), true)
            .ExecuteCommandHasChangeAsync();
    }

    public async Task<List<TrackTemplateContentEntity>> GetContentListAsync(
        Expression<Func<TrackTemplateContentEntity, bool>> whereExpression)
    {
        return await Context.Queryable<TrackTemplateContentEntity>().Where(whereExpression).ToListAsync();
    }

    public async Task<bool> UpdateContentRangeAsync(List<TrackTemplateContentEntity> updateObjs)
    {
        return await Context.Updateable(updateObjs).ExecuteCommandHasChangeAsync();
    }

    public async Task<T> ContentMaxAsync<T>(Expression<Func<TrackTemplateContentEntity, T>> columns,
        Expression<Func<TrackTemplateContentEntity, bool>> whereExpression)
    {
        return await Context.Queryable<TrackTemplateContentEntity>().Where(whereExpression).MaxAsync(columns);
    }

    public async Task<bool> UpdateContentAsync(Expression<Func<TrackTemplateContentEntity, bool>> columns,
        Expression<Func<TrackTemplateContentEntity, bool>> whereExpression)
    {
        return await Context.Updateable<TrackTemplateContentEntity>().SetColumns(columns).Where(whereExpression)
            .ExecuteCommandHasChangeAsync();
    }

    public async Task<List<TrackTemplateOutputVo>> GetTrackTemplateListAsync(GetTrackTemplateListInputVo input)
    {
        var templates = await Context.Queryable<TrackTemplateEntity>()
            .Where(x => x.SubSystemId == input.SubSystemId)
            .WhereIF(input.CustomerId.HasValue, x => x.CustomerId == input.CustomerId)
            .WhereIF(input.TemplateType.HasValue, x => x.CategoryId == input.TemplateType)
            .Select(x => new TrackTemplateOutputVo
            {
                Id = x.Id,
                TemplateName = x.Name,
                TemplateCode = x.Code,
            })
            .ToListAsync();

        if (templates == default) return new List<TrackTemplateOutputVo>();
        var templateIds = templates.Select(x => x.Id).ToArray();
        var contents = await Context.Queryable<TrackTemplateContentEntity>()
            .LeftJoin<TrackContentEntity>((a, b) => a.TrackContentId == b.Id)
            .LeftJoin<TrackStatusEntity>((a, b, c) => b.TrackStatusId == c.Id)
            .LeftJoin<TrackNodeEntity>((a, b, c, d) => c.Node == d.Id)
            .Where(a => templateIds.Contains(a.TrackTemplateId))
            .Select((a, b, c, d) => new TemplateContentDtoVo
            {
                TemplateId = a.TrackTemplateId,
                Code = b.Code,
                ContentCn = b.Content,
                ContentEn = b.EnContent,
                Status = c.Status,
                Node = d.NodeName
            })
            .ToListAsync();

        foreach (var template in templates)
        {
            var templateContents = contents.Where(x => x.TemplateId == template.Id).ToList();

            template.TemplateContents = templateContents;
        }

        return templates;
    }

    public async Task<List<string>> GetContentByTemplateCodes(string[] codes, int systemId)
    {

        var sql = @$"
            select
                distinct
                c.Code
            from t_track_template a
            left join t_track_template_content b on a.id = b.TrackTemplateId and b.IsDeleted = 0
            left join t_track_content c on b.TrackContentId = c.Id and c.IsDeleted = 0
            where
                a.SubSystemId = {systemId}
                and a.Code in (@codes)
                and a.IsDeleted = 0
        ";


        var list = Context.Ado.SqlQuery<string>(sql, new {codes = codes}).ToList();

        return list;
    }
}