using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;
using MMDAL.DTO.ConfigVersion;
using MMDAL.Query.ConfigVersion;
using Newtonsoft.Json;

namespace MMDAL.CustomCode.ConfigVersion
{
    public class ConfigVersionDAL : IConfigVersionDAL
    {
        private readonly IQueryExecutor _queryExecutor;
        private readonly IValidation _validation;

        public ConfigVersionDAL(IQueryExecutor queryExecutor, IValidation validation)
        {
            _queryExecutor = queryExecutor;
            _validation    = validation;
        }

        public async Task<string> GetConfigVersion(int configVersionId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                var sql        = ConfigVersionQB.GET_CONFIGVERSION;
                var parameters = new { ConfigVersionId = configVersionId, TenantId = login.ClientId };
                var dict       = new Dictionary<int, ConfigVersionDTO>();

                await _queryExecutor.QueryMultiMapAsync<ConfigVersionDTO, ConfigVersionMemberDTO, ConfigVersionDTO>(
                    login,
                    sql,
                    (parent, child) =>
                    {
                        if (!dict.TryGetValue(parent.ConfigVersionId, out var existing))
                        {
                            existing         = parent;
                            existing.Members = new List<ConfigVersionMemberDTO>();
                            dict[parent.ConfigVersionId] = existing;
                        }
                        if (child != null && child.ConfigVersionMemberId != 0)
                            existing.Members.Add(child);
                        return existing;
                    },
                    parameters,
                    splitOn: "ConfigVersionMemberId");

                return JsonConvert.SerializeObject(dict.Values.FirstOrDefault());
            }
            catch (Exception ex)
            {
                throw new Exception($"Failed to retrieve ConfigVersion: {ex.Message}", ex);
            }
        }

        public async Task<string> GetSelectListConfigVersion(LoginDTO login, CancellationToken ct)
        {
            try
            {
                var result = await _queryExecutor.QueryAsync<ConfigVersionPicklistDTO>(
                    login, ConfigVersionQB.GET_SELECTLIST_CONFIGVERSION, new { TenantId = login.ClientId });
                return JsonConvert.SerializeObject(result);
            }
            catch (Exception ex)
            {
                throw new Exception($"Failed to retrieve ConfigVersion list: {ex.Message}", ex);
            }
        }

        public async Task<int?> GetActiveConfigVersionIdAsync(LoginDTO login, CancellationToken ct)
        {
            try
            {
                var parameters = new
                {
                    TenantId   = login.ClientId,
                    ConfigType = 0,
                    AsOfDate   = DateTime.UtcNow.Date
                };
                return await _queryExecutor.ExecuteScalarAsync<int?>(
                    login, ConfigVersionQB.GET_ACTIVE_CONFIGVERSION_ID, parameters);
            }
            catch (Exception ex)
            {
                throw new Exception($"Failed to resolve active config version: {ex.Message}", ex);
            }
        }

        public async Task SaveConfigVersion(ConfigVersionDTO dto, LoginDTO login, CancellationToken ct)
        {
            try
            {
                await _queryExecutor.ExecuteAsync(login, ConfigVersionQB.SAVE_CONFIGVERSION, dto);
            }
            catch (Exception ex)
            {
                string error = await _validation.HandleException(ex, ErrorResponse.SaveErrorMessage);
                throw new Exception(error);
            }
        }

        public async Task UpdateConfigVersion(ConfigVersionDTO dto, LoginDTO login, CancellationToken ct)
        {
            try
            {
                await _queryExecutor.ExecuteAsync(login, ConfigVersionQB.UPDATE_CONFIGVERSION, dto);
            }
            catch (Exception ex)
            {
                string error = await _validation.HandleException(ex, ErrorResponse.UpdateErrorMessage);
                throw new Exception(error);
            }
        }

        public async Task<int> DeleteConfigVersion(int configVersionId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                var parameters = new { ConfigVersionId = configVersionId, TenantId = login.ClientId };
                return await _queryExecutor.ExecuteAsync(login, ConfigVersionQB.DELETE_CONFIGVERSION, parameters);
            }
            catch (Exception ex)
            {
                string error = await _validation.HandleException(ex, ErrorResponse.DeleteErrorMessage);
                throw new Exception(error);
            }
        }

        public async Task SaveMember(ConfigVersionMemberDTO member, LoginDTO login, CancellationToken ct)
        {
            try
            {
                await _queryExecutor.ExecuteAsync(login, ConfigVersionQB.SAVE_CONFIGVERSION_MEMBER, member);
            }
            catch (Exception ex)
            {
                string error = await _validation.HandleException(ex, ErrorResponse.SaveErrorMessage);
                throw new Exception(error);
            }
        }

        public async Task DeleteMembers(int configVersionId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                var parameters = new { ConfigVersionId = configVersionId, TenantId = login.ClientId };
                await _queryExecutor.ExecuteAsync(login, ConfigVersionQB.DELETE_CONFIGVERSION_MEMBERS, parameters);
            }
            catch (Exception ex)
            {
                string error = await _validation.HandleException(ex, ErrorResponse.DeleteErrorMessage);
                throw new Exception(error);
            }
        }

        public async Task<IEnumerable<ConfigVersionMemberDTO>> GetFormulasFromActiveCharges(LoginDTO login, CancellationToken ct)
        {
            try
            {
                return await _queryExecutor.QueryAsync<ConfigVersionMemberDTO>(
                    login, ConfigVersionQB.GET_FORMULAS_FROM_ACTIVE_CHARGES, new { TenantId = login.ClientId });
            }
            catch (Exception ex)
            {
                throw new Exception($"Failed to load formulas from active charges: {ex.Message}", ex);
            }
        }

        public async Task ArchivePreviousActive(int configVersionId, int configType, DateTime effectiveFrom, LoginDTO login, CancellationToken ct)
        {
            try
            {
                var parameters = new
                {
                    ConfigVersionId = configVersionId,
                    ConfigType      = configType,
                    EffectiveFrom   = effectiveFrom,
                    ModifiedById    = login.UserId,
                    TenantId        = login.ClientId
                };
                await _queryExecutor.ExecuteAsync(login, ConfigVersionQB.ARCHIVE_PREVIOUS_ACTIVE, parameters);
            }
            catch (Exception ex)
            {
                string error = await _validation.HandleException(ex, ErrorResponse.UpdateErrorMessage);
                throw new Exception(error);
            }
        }
    }
}