using FrameworkDAL.DTO.Data;
using FrameworkDAL.DTO.DocumentMap;
using FrameworkDAL.Query.DocumentMap;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;
using Newtonsoft.Json;

namespace FrameworkDAL.CustomCode.DocumentMap
{
    public class DocumentMapDAL : IDocumentMapDAL
    {
        private readonly IQueryExecutor _QueryExecutor;
        private readonly IValidation _Validation;

        public DocumentMapDAL(IQueryExecutor QueryExecutor, IValidation IValidation)
        {
            _QueryExecutor = QueryExecutor;
            _Validation = IValidation;
        }
        public async Task<string> GetDocumentMap(int EntityId, int BizTransactionClassId, int BizTransactionId, LoginDTO LoginDTO)
        {
            string Json = "";
            string sql = "";
            try
            {
                sql = DocumentMapQB.GET_DOCUMENTMAP;
                var parameters = new
                {
                    entityid = EntityId,
                    biztransactionclassid = BizTransactionClassId,
                    biztransactionid = BizTransactionId
                };
                IEnumerable<DocumentMapDTO> DocumentMapDTOs = await _QueryExecutor.QueryAsync<DocumentMapDTO>(LoginDTO, sql , parameters);
                if (DocumentMapDTOs == null || !DocumentMapDTOs.Any())
                {
                    throw new MethodAccessException("No document map found with the given DocumentMapId.");
                }

                if (DocumentMapDTOs.Count() > 1)
                {
                    throw new MethodAccessException("Multiple document maps found with the given DocumentMapId. Expected only one result.");
                }
                Json = JsonConvert.SerializeObject(DocumentMapDTOs);
                return Json;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<int> GetDocumentSetIdForEntity(int entityId, int bizTransactionTypeId, LoginDTO loginDTO)
        {
            try
            {
                int bizTransactionClassId = -1;
                int bizTransactionId = -1;

                if (bizTransactionTypeId != -1)
                {
                    var bizTransactionType = await _QueryExecutor.QuerySingleAsync<BizTransactionTypeClassAndTransactionDTO>(
                        loginDTO,
                        DocumentMapQB.GET_BIZTRANSACTIONTYPE_CLASS_TRANSACTION,
                        new { biztransactiontypeid = bizTransactionTypeId }
                    );

                    if (bizTransactionType != null)
                    {
                        bizTransactionClassId = bizTransactionType.BizTransactionClassId;
                        bizTransactionId = bizTransactionType.BiztransactionId;
                    }
                }

                var documentSetId = await _QueryExecutor.QuerySingleAsync<int?>(
                    loginDTO,
                    DocumentMapQB.GET_DOCUMENTSETID_FOR_ENTITY,
                    new { entityid = entityId, biztransactionclassid = bizTransactionClassId, biztransactionid = bizTransactionId }
                );

                return documentSetId ?? -1;
            }
            catch (Exception ex)
            {
                throw new Exception($"Failed to resolve DocumentSetId for EntityId {entityId}: {ex.Message}", ex);
            }
        }

        public async Task<int> SaveDocumentMap(DocumentMapDTO DocumentMapDTO, LoginDTO LoginDTO)
        {
            try
            {
                string Sql = DocumentMapQB.SAVE_DOCUMENTMAP;
                return await _QueryExecutor.ExecuteIdentityAsync(LoginDTO, Sql, DocumentMapDTO);
            }
            catch (Exception ex)
            {
                string Error = await _Validation.HandleException(ex, $"{ErrorResponse.SaveErrorMessage}");
                throw new Exception(Error);
            }
        }

        public async Task<int> UpdateDocumentMap(DocumentMapDTO DocumentMapDTO, LoginDTO LoginDTO)
        {
            try
            {
                string Sql = DocumentMapQB.UPDATE_DOCUMENTMAP;
                return await _QueryExecutor.ExecuteAsync(LoginDTO, Sql, DocumentMapDTO);
            }
            catch (Exception ex)
            {
                string Error = await _Validation.HandleException(ex, $"{ErrorResponse.UpdateErrorMessage}");
                throw new Exception(Error);
            }
        }

        public async Task<string> DeleteDocumentMap(int DocumentMapId, LoginDTO LoginDTO)
        {
            try
            {
                string Sql = DocumentMapQB.DELETE_DOCUMENTMAP;
                var Parameters = new { documentmapid = DocumentMapId };
                int result = await _QueryExecutor.ExecuteAsync(LoginDTO, Sql, Parameters);

                if (result > 0)
                {
                    return $"{SuccessResponse.DeleteSuccessMessage}";
                }
                else
                {
                    return $"{ErrorResponse.DeleteNotFoundMessage}";
                }
            }
            catch (Exception ex)
            {
                string Error = await _Validation.HandleException(ex, $"{ErrorResponse.DeleteErrorMessage}");
                throw new Exception(Error);
            }
        }
    }
}