using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using AdminDAL.CustomCode.IceData;
using AdminDAL.DTO.IceData;
using GB5Shared.DTO.Framework.AutoNumber;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.DateConverter;
using GB5Shared.Validation;
using Newtonsoft.Json;

namespace AdminBLL.IceData
{
    public class IceDataBLL : IIceDataBLL
    {
        private readonly IIceDataDAL _IceDataDAL;
        private readonly AutoNumber _AutoNumber;
        private readonly IValidation _Validation;

        public IceDataBLL(IIceDataDAL IceDataDAL, AutoNumber AutoNumber, IValidation Validation)
        {
            _IceDataDAL = IceDataDAL;
            _AutoNumber = AutoNumber;
            _Validation = Validation;
        }

        public async Task<string> GetIceDataFull(int IceDataId, LoginDTO LoginDTO)
        {
            try
            {
                return await _IceDataDAL.GetIceDataFull(IceDataId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task<IceDataDTO> GetIceData(int IceDataId, LoginDTO LoginDTO)
        {
            try
            {
                return await _IceDataDAL.GetIceData(IceDataId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task<IceDataDetailDTO> GetIceDataDetail(int IceDataDetailId, LoginDTO LoginDTO)
        {
            try
            {
                return await _IceDataDAL.GetIceDataDetail(IceDataDetailId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task<string> SaveIceData(IceDataDTO IceDataDTO, LoginDTO LoginDTO)
        {
            if (IceDataDTO == null)
                throw new ArgumentNullException(nameof(IceDataDTO));
            try
            {
                IceDataDTO.ModifiedById = LoginDTO.UserId;
                IceDataDTO.ModifiedOn = DateTime.UtcNow;
                bool isNew = IceDataDTO.IceDataId == 0;
                if (isNew)
                {
                    IceDataDTO.CreatedById = LoginDTO.UserId;
                    IceDataDTO.CreatedOn = DateTime.UtcNow;
                    if (IceDataDTO.IceDataDetailArray?.Count > 0)
                    {
                        foreach (var detail in IceDataDTO.IceDataDetailArray)
                        {
                            detail.CreatedById = LoginDTO.UserId;
                            detail.CreatedOn = DateTime.UtcNow;
                            detail.ModifiedById = LoginDTO.UserId;
                            detail.ModifiedOn = DateTime.UtcNow;
                        }
                    }
                    int newId = await _IceDataDAL.SaveIceData(IceDataDTO, LoginDTO);
                    IceDataDTO.IceDataId = newId;
                    return $"ICEDATA AND ICEDATADETAIL SAVED SUCCESSFULLY WITH ICEDATA ID {IceDataDTO.IceDataId}.";
                }
                else
                {
                    if (IceDataDTO.IceDataDetailArray?.Count > 0)
                    {
                        foreach (var detail in IceDataDTO.IceDataDetailArray)
                        {
                            detail.IceDataId = IceDataDTO.IceDataId;
                            detail.ModifiedById = LoginDTO.UserId;
                            detail.ModifiedOn = DateTime.UtcNow;
                            if (detail.IceDataDetailId == 0)
                            {
                                detail.CreatedById = LoginDTO.UserId;
                                detail.CreatedOn = DateTime.UtcNow;
                            }
                        }
                    }
                    await _IceDataDAL.UpdateIceDataFull(IceDataDTO, LoginDTO);
                    return $"ICEDATA AND ICEDATADETAIL UPDATED SUCCESSFULLY WITH ICEDATA ID {IceDataDTO.IceDataId}.";
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"Error saving IceData: {ex.Message}", ex);
            }
        }
        public async Task<string> UpdateIceData(IceDataDTO iceDataDTO, LoginDTO loginDTO)
        {
            int rows = await _IceDataDAL.UpdateIceData(iceDataDTO, loginDTO);

            if (rows <= 0)
                throw new Exception("No record updated.");

            return $"DETAILS UPDATED SUCCESSFULLY WITH ICEDATA ID {iceDataDTO.IceDataId}";
        }
        public async Task<string> DeleteIceData(int IceDataId, LoginDTO LoginDTO)
        {
            try
            {
                var detailsResult = await _IceDataDAL.DeleteIceDataDetail(IceDataId, LoginDTO);

                if (detailsResult <= 0)
                    return ("FAILED TO DELETE ICEDATADETAIL. PARENT NOT DELETED.");

                var parentResult = await _IceDataDAL.DeleteIceData(IceDataId, LoginDTO);

                if (parentResult <= 0)
                    return ("DETAIL DELETED, BUT FAILED TO DELETE ICEDATA.");

                return ("ICEDATA AND ICEDATADETAILS DELETED SUCCESSFULLY.");
            }
            catch (Exception ex)
            {
                throw new Exception($"ERROR DELETING ICEDATA ID {IceDataId}", ex);
            }
        }
        public async Task<string> DeleteDetailIceData(int IceDataDetailId, LoginDTO LoginDTO)
        {
            try
            {
                return await _IceDataDAL.DeleteIceDataDetailById(IceDataDetailId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task<string> GetSelectListIceDataFull(CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                var data = await _IceDataDAL.GetSelectListIceDataFull(CriteriaDTO, LoginDTO);
                var options = new JsonSerializerOptions
                {
                    PropertyNamingPolicy = null
                };
                options.AddGB5Converters();

                // Serialize to JSON string
                string json = System.Text.Json.JsonSerializer.Serialize(data, options);
                return json;
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task<string> GetSelectListIceData(CriteriaDTO criteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                return await _IceDataDAL.GetSelectListIceData(criteriaDTO, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task<string> GetSelectListIceDataDetail(CriteriaDTO criteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                return await _IceDataDAL.GetSelectListIceDataDetail(criteriaDTO, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

    }
}