using System.Linq.Expressions;
using SJZY.Track.Domain.Aggregates.TrackContentAggregate;
using SJZY.Track.Domain.Aggregates.TrackPullAggregate;
using SJZY.Track.Domain.Aggregates.TrackTemplateAggregate;
using SJZY.Track.Domain.Dtos.Common;
using SJZY.Track.Domain.Dtos.TrackPull;
using SJZY.Track.Domain.VEntities;

namespace SJZY.Track.Repository.Repositories;

public class TrackPullConfigRepository : BasicRepository<TrackPullConfigEntity>, ITrackPullConfigRepository,
    IScopedDependency
{
    public async Task<UnifyPageResultDto<GetTrackPullConfigPageOutputVO>> GetPageAsync(KeywordsInputVO input)
    {
        return await AsQueryable()
            .LeftJoin<VSystemEntity>((trackPull, system) => trackPull.SubSystemId == system.Id && !system.IsDeleted)
            .LeftJoin<VServiceProviderEntity>((trackPull, system, service) => trackPull.ServiceProviderId == service.Id && !service.IsDeleted)
            .LeftJoin<TrackTemplateEntity>((trackPull, system, service, template) => trackPull.TrackTemplateId == template.Id && !template.IsDeleted)
            .Filter(null, true)
            .Where(trackPull => !trackPull.IsDeleted)
            .WhereIF(input.SubSystemId.HasValue, trackPull => trackPull.SubSystemId == input.SubSystemId)
            .WhereIF(!input.Keywords.IsNullOrWhiteSpace(), (trackPull, system, service, template) => service.Name.Contains(input.Keywords) || template.Name.Contains(input.Keywords))
            .OrderByDescending(trackPull => trackPull.CreateTime)
            .Select((trackPull, system, service, template) => new GetTrackPullConfigPageOutputVO
            {
                Id = trackPull.Id,
                SubSystem = system.CnName,
                ServiceProvider = service.Name,
                TrackTemplate = template.Name,
                CreateTime = trackPull.CreateTime
            })
            .ToPagedListAsync(input.PageIndex, input.PageSize);
    }

    public async Task<UnifyPageResultDto<GetTrackPullContentPageOutputVO>> GetContentPageAsync(GetTrackPullContentPageInputVO input)
    {
        return await Context.Queryable<TrackPullContentConfigEntity>()
            .InnerJoin<TrackContentEntity>((pullContent, trackContent) => pullContent.TrackContentId == trackContent.Id)
            .InnerJoin<TrackPullConfigEntity>((pullContent, trackContent, trackPull) => pullContent.TrackPullConfigId == trackPull.Id)
            .InnerJoin<TrackTemplateContentEntity>((pullContent, trackContent, trackPull, templateContent) => trackPull.TrackTemplateId == templateContent.TrackTemplateId && pullContent.TrackContentId == templateContent.TrackContentId)
            .Where(pullContent => pullContent.TrackPullConfigId == input.TrackPullConfigId)
            .OrderBy((pullContent, trackContent, trackPull, templateContent) => templateContent.Sort)
            .Select((pullContent, trackContent, trackPull, templateContent) => new GetTrackPullContentPageOutputVO
            {
                Id = pullContent.Id
            }, true)
            .ToPagedListAsync(input.PageIndex, input.PageSize);
    }

    public async Task<GetTrackPullConfigDetailOutputVO> GetDetailAsync(int id)
    {
        return await AsQueryable()
            .LeftJoin<VSystemEntity>((trackPull, system) => trackPull.SubSystemId == system.Id && !system.IsDeleted)
            .LeftJoin<VServiceProviderEntity>((trackPull, system, service) => trackPull.ServiceProviderId == service.Id && !service.IsDeleted)
            .LeftJoin<TrackTemplateEntity>((trackPull, system, service, template) => trackPull.TrackTemplateId == template.Id && !template.IsDeleted)
            .InnerJoin<TrackPushPullParamsConfigEntity>((trackPull, system, service, template, paramsConfig) => trackPull.Id == paramsConfig.PullOrPushConfigId && !paramsConfig.IsPush && !paramsConfig.IsDeleted)
            .Filter(null, true)
            .Where(trackPull => trackPull.Id == id && !trackPull.IsDeleted)
            .Select((trackPull, system, service, template, paramsConfig) => new GetTrackPullConfigDetailOutputVO
            {
                Id = trackPull.Id,
                SubSystem = system.CnName,
                ServiceProvider = service.Name,
                TrackTemplate = template.Name
            }, true)
            .SingleAsync();
    }

    public async Task<GetTrackPullContentDetailOutputVO> GetContentDetailAsync(int id)
    {
        return await Context.Queryable<TrackPullContentConfigEntity>()
            .InnerJoin<TrackContentEntity>((pullContent, trackContent) => pullContent.TrackContentId == trackContent.Id)
            .Where(pullContent => pullContent.Id == id)
            .Select((pullContent, trackContent) => new GetTrackPullContentDetailOutputVO
            {
                Id = pullContent.Id,
                Code = trackContent.Code + "-" + trackContent.Content,
            }, true)
            .Mapper(x =>
            {
                x.TrackKeywords = x.TrackKeyword?.Split(',').ToList();
                x.TrackKeywordReverses = x.TrackKeywordReverse?.Split(',').ToList();
            })
            .SingleAsync();
    }

    public async Task<bool> InsertParamsAsync(TrackPushPullParamsConfigEntity insertObj)
    {
        return await Context.Insertable(insertObj).ExecuteCommandAsync() > 0;
    }

    public async Task<bool> InsertContentRangeAsync(List<TrackPullContentConfigEntity> insertObjs)
    {
        return await Context.Insertable(insertObjs).ExecuteCommandAsync() > 0;
    }

    public async Task<TrackPushPullParamsConfigEntity> GetParamsSingleAsync(Expression<Func<TrackPushPullParamsConfigEntity, bool>> whereExpression)
    {
        return await Context.Queryable<TrackPushPullParamsConfigEntity>().SingleAsync(whereExpression);
    }

    public async Task<bool> UpdateParamsAsync(TrackPushPullParamsConfigEntity updateObj)
    {
        return await Context.Updateable(updateObj).ExecuteCommandHasChangeAsync();
    }

    public async Task<bool> SoftDeleteContentAsync(Expression<Func<TrackPullContentConfigEntity, bool>> whereExpression)
    {
        return await Context.Updateable<TrackPullContentConfigEntity>()
            .Where(whereExpression)
            .SetColumns(nameof(ISoftDeleteBasicEntity.IsDeleted), true)
            .ExecuteCommandHasChangeAsync();
    }

    public async Task<bool> SoftDeleteParamsAsync(Expression<Func<TrackPushPullParamsConfigEntity, bool>> whereExpression)
    {
        return await Context.Updateable<TrackPushPullParamsConfigEntity>()
            .Where(whereExpression)
            .SetColumns(nameof(ISoftDeleteBasicEntity.IsDeleted), true)
            .ExecuteCommandHasChangeAsync();
    }

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

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

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