using GB5Shared.DTO.Framework.AutoNumber;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.QueryExecutor;
using PayRollDAL.CustomeCode.Policy;
using PayRollDAL.DTO.Policy;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace PayRollBLL.Policy
{
    public class PolicyBLL : IPolicyBLL
    {
        private readonly IPolicyDAL _PolicyDAL;
        private readonly AutoNumber _AutoNumber;
        private readonly IQueryExecutor _QueryExecutor;

        public PolicyBLL(
            IPolicyDAL policyDAL,
            AutoNumber autoNumber,
            IQueryExecutor queryExecutor)
        {
            _PolicyDAL = policyDAL;
            _AutoNumber = autoNumber;
            _QueryExecutor = queryExecutor;
        }

        // ── Get single record ─────────────────────────────────────────────

        public async Task<PolicyDTO> GetPolicy(int PolicyId, LoginDTO LoginDTO)
        {
            return await _PolicyDAL.GetPolicy(PolicyId, LoginDTO).ConfigureAwait(false);
        }

        // ── Save (insert or update) ───────────────────────────────────────

        public async Task<string> SavePolicy(PolicyDTO PolicyDTO, LoginDTO LoginDTO)
        {
            if (PolicyDTO == null)
                throw new ArgumentNullException(nameof(PolicyDTO));

            bool isNew = PolicyDTO.PolicyId == 0;
            AutoNumberDTO? autoNumberDTO = null;

            var trans = await _QueryExecutor.BeginTransactionAsync(LoginDTO).ConfigureAwait(false);
            try
            {
                int versionCount = PolicyDTO.PolicyVersionArray?.Count ?? 0;
                int detailCount = 0;
                if (PolicyDTO.PolicyVersionArray != null)
                {
                    foreach (var version in PolicyDTO.PolicyVersionArray)
                        detailCount += version.PolicyVersionDetailArray?.Count ?? 0;
                }

                if (isNew)
                {
                    int count = 1 + versionCount + detailCount;
                    autoNumberDTO = await _AutoNumber.GetNumberAsync(count, "POLICY", LoginDTO)
                        .ConfigureAwait(false);

                    PolicyDTO.PolicyId = autoNumberDTO.StartNumber;
                    PolicyDTO.PolicyCreatedById = LoginDTO.UserId;
                    PolicyDTO.PolicyCreatedOn = DateTime.UtcNow;

                    int tmpCount = 1;
                    if (PolicyDTO.PolicyVersionArray != null)
                    {
                        foreach (var version in PolicyDTO.PolicyVersionArray)
                        {
                            version.PolicyVersionId = autoNumberDTO.StartNumber + tmpCount;
                            tmpCount++;

                            if (version.PolicyVersionDetailArray != null)
                            {
                                foreach (var detail in version.PolicyVersionDetailArray)
                                {
                                    detail.PolicyVersionDetailId = autoNumberDTO.StartNumber + tmpCount;
                                    tmpCount++;
                                }
                            }
                        }
                    }
                }
                else if (PolicyDTO.PolicyVersionArray != null && PolicyDTO.PolicyVersionArray.Count > 0)
                {
                    // Existing policy: allocate ids only for new (version change) rows
                    int newVersionCount = 0;
                    foreach (var version in PolicyDTO.PolicyVersionArray)
                    {
                        if (version.PolicyVersionId == 0) newVersionCount++;
                        newVersionCount += version.PolicyVersionDetailArray?.Count(d => d.PolicyVersionDetailId == 0) ?? 0;
                    }

                    if (newVersionCount > 0)
                    {
                        autoNumberDTO = await _AutoNumber.GetNumberAsync(newVersionCount, "POLICY", LoginDTO)
                            .ConfigureAwait(false);

                        int tmpCount = 0;
                        foreach (var version in PolicyDTO.PolicyVersionArray)
                        {
                            if (version.PolicyVersionId == 0)
                                version.PolicyVersionId = autoNumberDTO.StartNumber + tmpCount++;

                            if (version.PolicyVersionDetailArray != null)
                            {
                                foreach (var detail in version.PolicyVersionDetailArray)
                                {
                                    if (detail.PolicyVersionDetailId == 0)
                                        detail.PolicyVersionDetailId = autoNumberDTO.StartNumber + tmpCount++;
                                }
                            }
                        }
                    }
                }

                PolicyDTO.PolicyModifiedById = LoginDTO.UserId;
                PolicyDTO.PolicyModifiedOn = DateTime.UtcNow;

                int rows = isNew
                    ? await _PolicyDAL.SavePolicy(PolicyDTO, LoginDTO, trans).ConfigureAwait(false)
                    : await _PolicyDAL.UpdatePolicy(PolicyDTO, LoginDTO, trans).ConfigureAwait(false);

                await _QueryExecutor.CommitAsync(trans).ConfigureAwait(false);

                if (rows <= 0)
                    return isNew ? "Failed to save policy." : "Failed to update policy.";

                return isNew
                    ? $"Details Saved Successfully With Id :{PolicyDTO.PolicyId}"
                    : $"Details Updated Successfully With Id :{PolicyDTO.PolicyId}";
            }
            catch (Exception)
            {
                await _QueryExecutor.RollbackAsync(trans).ConfigureAwait(false);
                if (autoNumberDTO != null)
                    await _AutoNumber.RollbackAutoNumber("POLICY", autoNumberDTO.StartNumber, LoginDTO)
                        .ConfigureAwait(false);
                throw;
            }
        }

        // ── Delete ────────────────────────────────────────────────────────

        public async Task<string> DeletePolicy(int PolicyId, LoginDTO LoginDTO)
        {
            return await _PolicyDAL.DeletePolicy(PolicyId, LoginDTO).ConfigureAwait(false);
        }

        // ── Picklist ──────────────────────────────────────────────────────

        public async Task<string> GetSelectListPolicy(int FirstNumber, int MaxResult, CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            return await _PolicyDAL
                .GetSelectListPolicy(FirstNumber, MaxResult, CriteriaDTO, LoginDTO)
                .ConfigureAwait(false);
        }

        // ── Get a policy version, optionally as-of a FromDate ────────────

        public async Task<PolicyVersionDTO> GetPolicyVersion(int PolicyVersionId, DateTime? FromDate, LoginDTO LoginDTO)
        {
            return FromDate.HasValue
                ? await _PolicyDAL.GetPolicyVersionByFromDate(PolicyVersionId, FromDate.Value, LoginDTO).ConfigureAwait(false)
                : await _PolicyDAL.GetPolicyVersion(PolicyVersionId, LoginDTO).ConfigureAwait(false);
        }

        // ── Policy Version Picklist Report (cross-policy) ────────────────

        public async Task<string> GetPolicyVersionPicklistReport(int FirstNumber, int MaxResult, CriteriaDTO CriteriaDTO, LoginDTO LoginDTO, bool IsCount = false)
        {
            return await _PolicyDAL
                .GetPolicyVersionPicklistReport(FirstNumber, MaxResult, CriteriaDTO, LoginDTO, IsCount)
                .ConfigureAwait(false);
        }
    }
}