using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using FrameworkDAL.CustomCode.EntityViewer.DTOs;
using FrameworkDAL.Query.EntityViewer;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;

namespace FrameworkDAL.CustomCode.EntityViewer
{
    public class EntityLayoutDAL : IEntityLayoutDAL
    {
        private readonly IQueryExecutor _QueryExecutor;
        private readonly IValidation    _Validation;

        public EntityLayoutDAL(IQueryExecutor queryExecutor, IValidation validation)
        {
            _QueryExecutor = queryExecutor;
            _Validation    = validation;
        }

        public async Task<int> SaveLayout(EntityLayoutDTO dto, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                dto.CreatedById  = loginDTO.UserId;
                dto.ModifiedById = loginDTO.UserId;
                return await _QueryExecutor.ExecuteIdentityAsync(loginDTO, EntityLayoutQB.SAVE_LAYOUT, dto);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.SaveErrorMessage));
            }
        }

        public async Task<int> UpdateLayout(EntityLayoutDTO dto, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                dto.ModifiedById = loginDTO.UserId;
                return await _QueryExecutor.ExecuteAsync(loginDTO, EntityLayoutQB.UPDATE_LAYOUT_HEADER, dto, cancellationToken: ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.UpdateErrorMessage));
            }
        }

        public async Task<int> DeleteLayout(
            int entityLayoutId, int modifiedById, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.ExecuteAsync(loginDTO, EntityLayoutQB.DELETE_LAYOUT_HEADER,
                    new { EntityLayoutId = entityLayoutId, ModifiedById = modifiedById }, cancellationToken: ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.DeleteErrorMessage));
            }
        }

        public async Task<EntityLayoutDTO?> GetLayoutHeaderById(
            int entityLayoutId, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.QuerySingleAsync<EntityLayoutDTO>(
                    loginDTO, EntityLayoutQB.GET_LAYOUT_HEADER_BY_ID,
                    new { EntityLayoutId = entityLayoutId }, cancellationToken: ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.GetFetchingMessge));
            }
        }

        public async Task<EntityLayoutVersionDTO?> GetActiveLayout(
            string entityCode, int tenantId, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.QuerySingleAsync<EntityLayoutVersionDTO>(
                    loginDTO, EntityLayoutQB.GET_ACTIVE_LAYOUT,
                    new { EntityCode = entityCode, TenantId = tenantId }, cancellationToken: ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.GetFetchingMessge));
            }
        }

        public async Task<int> SaveLayoutVersion(
            EntityLayoutVersionDTO dto, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                dto.CreatedById  = loginDTO.UserId;
                dto.ModifiedById = loginDTO.UserId;
                return await _QueryExecutor.ExecuteIdentityAsync(loginDTO, EntityLayoutQB.SAVE_LAYOUT_VERSION, dto);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.SaveErrorMessage));
            }
        }

        public async Task<int> UpdateLayoutVersion(
            EntityLayoutVersionDTO dto, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                dto.ModifiedById = loginDTO.UserId;
                return await _QueryExecutor.ExecuteAsync(loginDTO, EntityLayoutQB.UPDATE_LAYOUT_VERSION, dto, cancellationToken: ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.UpdateErrorMessage));
            }
        }

        public async Task<int> DeleteLayoutVersion(
            int entityLayoutVersionId, int modifiedById, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.ExecuteAsync(loginDTO, EntityLayoutQB.DELETE_LAYOUT_VERSION,
                    new { EntityLayoutVersionId = entityLayoutVersionId, ModifiedById = modifiedById }, cancellationToken: ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.DeleteErrorMessage));
            }
        }

        public async Task<IReadOnlyList<EntityLayoutVersionDTO>> GetLayoutVersionList(
            int entityLayoutId, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                var result = await _QueryExecutor.QueryAsync<EntityLayoutVersionDTO>(
                    loginDTO, EntityLayoutQB.GET_LAYOUT_VERSION_LIST,
                    new { EntityLayoutId = entityLayoutId }, cancellationToken: ct);
                return (result ?? []).ToList();
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.GetFetchingMessge));
            }
        }

        public async Task<IReadOnlyList<EntityLayoutListItemDTO>> GetLayoutList(
            bool isComponent, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                var result = await _QueryExecutor.QueryAsync<EntityLayoutListItemDTO>(
                    loginDTO, EntityLayoutQB.GET_LAYOUT_LIST,
                    new { IsComponent = isComponent }, cancellationToken: ct);
                return (result ?? []).ToList();
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.GetFetchingMessge));
            }
        }

        public async Task ArchiveActiveVersion(
            int entityLayoutId, int modifiedById, LoginDTO loginDTO, DbTransaction tx, CancellationToken ct = default)
        {
            try
            {
                await _QueryExecutor.ExecuteAsync(loginDTO, EntityLayoutQB.ARCHIVE_ACTIVE_VERSION,
                    new { EntityLayoutId = entityLayoutId, ModifiedById = modifiedById }, tx, ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.UpdateErrorMessage));
            }
        }

        public async Task ActivateVersion(
            int entityLayoutVersionId, int modifiedById, LoginDTO loginDTO, DbTransaction tx, CancellationToken ct = default)
        {
            try
            {
                await _QueryExecutor.ExecuteAsync(loginDTO, EntityLayoutQB.ACTIVATE_VERSION,
                    new { EntityLayoutVersionId = entityLayoutVersionId, ModifiedById = modifiedById }, tx, ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.UpdateErrorMessage));
            }
        }
    }
}