//--------------------------------------------------------------------
//     此代码由liquid模板自动生成  byzhouhang 20240909
//     生成时间 2026-03-10 06:17:28Z 
//     对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//--------------------------------------------------------------------
using IRaCIS.Core.Domain.Models;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Infrastructure.Extention;
using System.Threading.Tasks;
using IRaCIS.Core.Infra.EFCore;
using Microsoft.Extensions.Logging;
namespace IRaCIS.Core.Application.Service;
	
/// <summary>
/// 分割
/// </summary>
/// <param name="_segmentationRepository"></param>
/// <param name="_mapper"></param>
/// <param name="_userInfo"></param>
/// <param name="_localizer"></param>
[ ApiExplorerSettings(GroupName = "Reading")]
public class SegmentationService(IRepository<Segmentation> _segmentationRepository,
    IRepository<SegmentBinding> _segmentBindingRepository,
    IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswerRepository,
      IRepository<VisitTask> _visitTaskRepository,
     IRepository<ReadingTableAnswerRowInfo> _readingTableAnswerRowInfoRepository,
     IRepository<ReadingTableQuestionAnswer> _readingTableQuestionAnswerRepository,
    IRepository<Segment> _segmentRepository,
                                  IMapper _mapper, IUserInfo _userInfo, IStringLocalizer _localizer): BaseService, ISegmentationService
{

	
    /// <summary>
    /// 获取分割组
    /// </summary>
    /// <param name="inQuery"></param>
    /// <returns></returns>
	[HttpPost]
	public async Task<PageOutput<SegmentationView>>  GetSegmentationList(SegmentationQuery inQuery)
	{
			
		    var segmentationQueryable =_segmentationRepository
            .WhereIf(inQuery.SegmentationName.IsNotNullOrEmpty(),x=>x.SegmentationName.Contains(inQuery.SegmentationName))
            .WhereIf(inQuery.TrialId != null, x => x.TrialId == inQuery.TrialId)
            .WhereIf(inQuery.SeriesId != null, x => x.SeriesId == inQuery.SeriesId)
            .WhereIf(inQuery.StudyId != null, x => x.StudyId == inQuery.StudyId)
            .WhereIf(inQuery.SubjectId != null, x => x.SubjectId == inQuery.SubjectId)
            .WhereIf(inQuery.SubjectVisitId != null, x => x.SubjectVisitId == inQuery.SubjectVisitId)
            .WhereIf(inQuery.VisitTaskId != null, x => x.VisitTaskId == inQuery.VisitTaskId)
            .ProjectTo<SegmentationView>(_mapper.ConfigurationProvider);

            var pageList= await segmentationQueryable.ToPagedListAsync(inQuery);

        return pageList;
	}


    /// <summary>
    /// 新增修改分割组
    /// </summary>
    /// <param name="addOrEditSegmentation"></param>
    /// <returns></returns>
    [HttpPost]
    public async  Task<IResponseOutput> AddOrUpdateSegmentation(SegmentationAddOrEdit addOrEditSegmentation)
	{
		  


			var entity = await _segmentationRepository.InsertOrUpdateAsync(addOrEditSegmentation, true);

        return ResponseOutput.Ok(entity.Id.ToString());
		
	}


    /// <summary>
    /// 删除分割组
    /// </summary>
    /// <param name="segmentationId"></param>
    /// <returns></returns>
    [HttpDelete("{segmentationId:guid}")]
    public async Task<IResponseOutput> DeleteSegmentation(Guid segmentationId)
	{
			var success = await _segmentationRepository.DeleteFromQueryAsync(t => t.Id == segmentationId,true);
            return ResponseOutput.Ok();
	}


    /// <summary>
    /// 获取分割
    /// </summary>
    /// <param name="inQuery"></param>
    /// <returns></returns>
    [HttpPost]
    public async Task<PageOutput<SegmentView>> GetSegmentList(SegmentQuery inQuery)
    {

        var segmentQueryable = _segmentRepository
           
            .WhereIf(inQuery.SegmentationId != null, x => x.SegmentationId == inQuery.SegmentationId)
             .WhereIf(inQuery.SegmentName.IsNotNullOrEmpty(), x => x.SegmentName.Contains(inQuery.SegmentName))
            .WhereIf(inQuery.VisitTaskId != null, x => x.VisitTaskId == inQuery.VisitTaskId)
                                    .ProjectTo<SegmentView>(_mapper.ConfigurationProvider);

        var pageList = await segmentQueryable.ToPagedListAsync(inQuery);

        return pageList;
    }


    /// <summary>
    /// 新增修改分割
    /// </summary>
    /// <param name="addOrEditSegment"></param>
    /// <returns></returns>
    [HttpPost]
    public async Task<IResponseOutput> AddOrUpdateSegment(SegmentAddOrEdit addOrEditSegment)
    {



        var entity = await _segmentRepository.InsertOrUpdateAsync(addOrEditSegment, true);

        return ResponseOutput.Ok(entity.Id.ToString());

    }

    /// <summary>
    /// 删除分割
    /// </summary>
    /// <param name="inQuery"></param>
    /// <returns></returns>
    [HttpDelete("{segmentId:guid}")]
    public async Task<IResponseOutput> DeleteSegment(Guid segmentId)
    {
        var success = await _segmentRepository.DeleteFromQueryAsync(t => t.Id == segmentId, true);
        return ResponseOutput.Ok();
    }


    /// <summary>
    /// 获取分割绑定
    /// </summary>
    /// <param name="inQuery"></param>
    /// <returns></returns>
    [HttpPost]
    public async Task<PageOutput<SegmentBindingView>> GetSegmentBindingList(SegmentBindingQuery inQuery)
    {

        var segmentBindingQueryable = _segmentBindingRepository
             .WhereIf(inQuery.QuestionId != null, x => x.QuestionId == inQuery.QuestionId)
             .WhereIf(inQuery.RowId != null, x => x.RowId == inQuery.RowId)
             .WhereIf(inQuery.SegmentId != null, x => x.SegmentId == inQuery.SegmentId)
             .WhereIf(inQuery.SegmentationId != null, x => x.SegmentationId == inQuery.SegmentationId)
             .WhereIf(inQuery.TableQuestionId != null, x => x.TableQuestionId == inQuery.TableQuestionId)
             .WhereIf(inQuery.VisitTaskId != null, x => x.VisitTaskId == inQuery.VisitTaskId)
             .ProjectTo<SegmentBindingView>(_mapper.ConfigurationProvider);

        var pageList = await segmentBindingQueryable.ToPagedListAsync(inQuery);

        return pageList;
    }


    /// <summary>
    /// 新增修改分割绑定
    /// </summary>
    /// <param name="addOrEditSegmentBinding"></param>
    /// <returns></returns>
    public async Task<IResponseOutput> AddOrUpdateSegmentBinding(SegmentBindingAddOrEdit addOrEditSegmentBinding)
    {
    


        var entity = await _segmentBindingRepository.InsertOrUpdateAsync(addOrEditSegmentBinding, true);

        return ResponseOutput.Ok(entity.Id.ToString());

    }

    /// <summary>
    /// 删除分割
    /// </summary>
    /// <param name="segmentBindingId"></param>
    /// <returns></returns>
    [HttpDelete("{segmentBindingId:guid}")]
    public async Task<IResponseOutput> DeleteSegmentBinding(Guid segmentBindingId)
    {
        var success = await _segmentBindingRepository.DeleteFromQueryAsync(t => t.Id == segmentBindingId, true);
        return ResponseOutput.Ok();
    }

    /// <summary>
    /// 保存分割绑定和答案
    /// </summary>
    /// <param name="inDto"></param>
    /// <returns></returns>
    public async Task<IResponseOutput> SaveSegmentBindingAndAnswer(SaveSegmentBindingAndAnswerInDto inDto)
    {

        var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId)
            .FirstNotNullAsync();
        foreach (var item in inDto.BindingList)
        {
            // 处理绑定关系
            var binding = await _segmentBindingRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.QuestionId == item.QuestionId && x.RowId == item.RowId && x.TableQuestionId == item.TableQuestionId)
                .FirstOrDefaultAsync();
            if (binding == null)
            {
                if (item.SegmentationId != null && item.SegmentId != null)
                {
                    await _segmentBindingRepository.InsertFromDTOAsync(new SegmentBinding
                    {
                        VisitTaskId = inDto.VisitTaskId,
                        QuestionId = item.QuestionId,
                        RowId = item.RowId,
                        TableQuestionId = item.TableQuestionId,
                        SegmentId = item.SegmentId.Value,
                        SegmentationId = item.SegmentationId.Value,
                    });
                }
               
            }
            else
            {
                if (item.SegmentationId != null && item.SegmentId != null)
                {
                    await _segmentBindingRepository.UpdatePartialFromQueryAsync(x => x.Id == binding.Id, t => new SegmentBinding
                    {
                        SegmentId = item.SegmentId.Value,
                        SegmentationId = item.SegmentationId.Value,
                    });
                }
                else
                {
                    await _segmentBindingRepository.DeleteFromQueryAsync(x => x.Id == binding.Id);
                }
              
            }



            // 处理问题
            if (item.RowId != null && item.TableQuestionId != null)
            {
                var answer = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.RowId == item.VisitTaskId && x.TableQuestionId == item.TableQuestionId)
                  .FirstOrDefaultAsync();
                var rowinfo= await _readingTableAnswerRowInfoRepository.Where(x => x.Id==item.RowId)
                    .Include(x=>x.VisitTask)
                    .FirstNotNullAsync();
                if (answer != null)
                {
                    await _readingTableQuestionAnswerRepository.UpdatePartialFromQueryAsync(x => x.Id == answer.Id, t => new ReadingTableQuestionAnswer
                    {
                        Answer = item.Answer
                    });
                }
                else
                {
                    await _readingTableQuestionAnswerRepository.InsertFromDTOAsync(new ReadingTableQuestionAnswer
                    {
                        VisitTaskId = inDto.VisitTaskId,
                        RowId = item.RowId.Value,
                        TableQuestionId = item.TableQuestionId.Value,
                        Answer = item.Answer,
                        TrialId= rowinfo.VisitTask.TrialId,
                        RowIndex= rowinfo.RowIndex,
                    });
                }
            }
            else
            {

                var answer = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId &&x.ReadingQuestionTrialId==item.QuestionId)
                  .FirstOrDefaultAsync();

                if (answer != null)
                {
                    await _readingTaskQuestionAnswerRepository.UpdatePartialFromQueryAsync(x => x.Id == answer.Id, t => new ReadingTaskQuestionAnswer
                    {
                        Answer = item.Answer
                    });
                }
                else
                {
                    await _readingTaskQuestionAnswerRepository.InsertFromDTOAsync(new ReadingTaskQuestionAnswer
                    {
                       ReadingQuestionTrialId= item.QuestionId.Value,
                        ReadingQuestionCriterionTrialId=taskinfo.TrialReadingCriterionId,
                        TrialId= taskinfo.TrialId,
                        SubjectId= taskinfo.SubjectId,
                        VisitTaskId = inDto.VisitTaskId,
                        Answer=item.Answer,
                    });
                }
            }


           
        }

        await _segmentationRepository.SaveChangesAsync();
        return ResponseOutput.Ok();
    }

}