using DevadminDAL.CustomCode.Replicate;
using DevadminDAL.DTO.Replicate;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.Resource.Response;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DevadminBLL.Replicate
{
    public class ReplicateBLL : IReplicateBLL
    {
        private readonly IReplicateDAL _ReplicateDAL;

        public ReplicateBLL(IReplicateDAL IReplicateDAL)
        {
            _ReplicateDAL = IReplicateDAL;
        }

        public async Task<string> GetReplicate(int ReplicateId, LoginDTO LoginDTO)
        {
            try
            {
                return await _ReplicateDAL.GetReplicate(ReplicateId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<IEnumerable<ReplicateListDTO>> GetReplicateList(LoginDTO loginDTO, CancellationToken ct)
            => await _ReplicateDAL.GetReplicateList(loginDTO, ct).ConfigureAwait(false);

        public async Task<string> SaveReplicate(ReplicateDTO dto, LoginDTO loginDTO, CancellationToken ct)
        {
            if (dto is null) throw new ArgumentNullException(nameof(dto));
            if (dto.ReplicateFromServerId <= 0) throw new ArgumentException("ReplicateFromServerId is required.", nameof(dto));
            if (dto.ReplicateToServerId <= 0) throw new ArgumentException("ReplicateToServerId is required.", nameof(dto));
            if (dto.DatasetId <= 0) throw new ArgumentException("DatasetId is required.", nameof(dto));

            bool isNew = dto.ReplicateId == 0;
            var now = DateTime.UtcNow;

            if (isNew)
            {
                dto.ReplicateCreatedById = loginDTO.UserId;
                dto.ReplicateCreatedOn   = now;
                dto.ReplicateStatus      = dto.ReplicateStatus == 0 ? (byte)1 : dto.ReplicateStatus;
                dto.ReplicateVersion     = 1;
                if (dto.ReplicateSourceType == 0) dto.ReplicateSourceType = 5;
            }
            dto.ReplicateModifiedById = loginDTO.UserId;
            dto.ReplicateModifiedOn   = now;

            if (isNew)
            {
                dto.ReplicateId = await _ReplicateDAL.InsertReplicate(dto, loginDTO, ct).ConfigureAwait(false);
                return $"{SuccessResponse.SaveSuccessMessage} {dto.ReplicateId}";
            }

            await _ReplicateDAL.UpdateReplicate(dto, loginDTO, ct).ConfigureAwait(false);
            return SuccessResponse.UpdateSuccess;
        }

        public async Task<string> DeleteReplicate(int replicateId, LoginDTO loginDTO, CancellationToken ct)
        {
            if (replicateId <= 0) throw new ArgumentException("ReplicateId is required.", nameof(replicateId));
            await _ReplicateDAL.DeleteReplicate(replicateId, loginDTO, ct).ConfigureAwait(false);
            return SuccessResponse.DeleteSuccessMessage;
        }
    }
}