using AutoMapper;
using Entities.Contracts;
using Entities.DTO;
using SharedDATA.Api;
using TechHelper.Server.Repository;
using TechHelper.Services;

namespace TechHelper.Server.Services
{

	public class ExamService2 : IExamService2
	{
		private readonly IUnitOfWork _unitOfWork;
		private readonly IExamRepository _examRepository;
		private readonly IMapper _mapper;

		public ExamService2(IUnitOfWork unitOfWork, IExamRepository examRepository, IMapper mapper)
		{
			_unitOfWork = unitOfWork;
			_examRepository = examRepository;
			_mapper = mapper;
		}

		public async Task<Guid> CreateExamAsync(ExamDto examDto, Guid creatorId)
		{
			if (examDto.QuestionGroups == null)
			{
				throw new ArgumentException("试卷必须包含一个根题组。");
			}

			// 使用 AutoMapper 将 DTO 映射到实体
			var assignment = _mapper.Map<Assignment>(examDto);

			// 设置后端生成的属性
			assignment.Id = Guid.NewGuid();
			assignment.CreatedBy = creatorId;
			assignment.CreatedAt = DateTime.UtcNow;

			// 递归设置所有子实体的ID和关联关系
			SetEntityIdsAndRelations(assignment.AssignmentGroups.First(), assignment.Id, creatorId);

			await _examRepository.AddAsync(assignment);
			await _unitOfWork.SaveChangesAsync();

			return assignment.Id;
		}

		private void SetEntityIdsAndRelations(AssignmentGroup group, Guid? assignmentId, Guid creatorId)
		{
			group.Id = Guid.NewGuid();
			group.AssignmentId = assignmentId;

			foreach (var aq in group.AssignmentQuestions)
			{
				aq.Id = Guid.NewGuid();
				aq.AssignmentGroupId = group.Id;
				aq.Question.Id = Guid.NewGuid();
				aq.Question.CreatedBy = creatorId;
				aq.CreatedAt = DateTime.UtcNow;
				// ... 其他默认值
			}

			foreach (var childGroup in group.ChildAssignmentGroups)
			{
				// 子题组的 AssignmentId 为 null，通过 ParentGroup 关联
				SetEntityIdsAndRelations(childGroup, null, creatorId);
				childGroup.ParentGroup = group.Id;
			}
		}

		public async Task<ExamDto> GetExamByIdAsync(Guid id)
		{
			var assignment = await _examRepository.GetFullExamByIdAsync(id);
			if (assignment == null)
			{

				throw new InvalidOperationException("");
			}

			return _mapper.Map<ExamDto>(assignment);
		}

		public async Task<IEnumerable<ExamDto>> GetAllExamPreviewsAsync(Guid userId)
		{
			var assignments = await _examRepository.GetExamPreviewsByUserAsync(userId);
			return _mapper.Map<IEnumerable<ExamDto>>(assignments);
		}

		public async Task AddAsync(QuestionGroupDto qg)
		{
			if (qg.ValidQuestionGroup)
			{
				var mapQG = _mapper.Map<QuestionGroup>(qg);
			}
		}

		public Task<ApiResponse> GetAllAsync(QueryParameter query)
		{
			throw new NotImplementedException();
		}

		public Task<ApiResponse> GetAsync(Guid id)
		{
			throw new NotImplementedException();
		}

		public Task<ApiResponse> AddAsync(ExamDto model)
		{
			throw new NotImplementedException();
		}

		public Task<ApiResponse> UpdateAsync(ExamDto model)
		{
			throw new NotImplementedException();
		}

		public Task<ApiResponse> DeleteAsync(Guid id)
		{
			throw new NotImplementedException();
		}
	}

}