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

namespace FrameworkDAL.CustomCode.GOP
{
    public class GopTargetOperationDAL : IGopTargetOperationDAL
    {
        private readonly IQueryExecutor _QueryExecutor;
        private readonly IValidation    _Validation;

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

        public async Task<GopTargetOperationDTO?> GetById(
            int targetOperationId, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.QuerySingleAsync<GopTargetOperationDTO>(
                    loginDTO,
                    GopTargetOperationQB.GET_BY_ID,
                    new { TenantId = loginDTO.ClientId, TargetOperationId = targetOperationId },
                    cancellationToken: ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.GetFetchingMessge));
            }
        }

        public async Task<IEnumerable<GopTargetOperationDTO>> GetList(
            LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.QueryAsync<GopTargetOperationDTO>(
                    loginDTO,
                    GopTargetOperationQB.GET_LIST,
                    new { TenantId = loginDTO.ClientId },
                    cancellationToken: ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.GetFetchingMessge));
            }
        }

        public async Task<IEnumerable<GopTargetOperationSelectListDTO>> GetSelectList(
            LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.QueryAsync<GopTargetOperationSelectListDTO>(
                    loginDTO,
                    GopTargetOperationQB.GET_SELECTLIST_TARGET_OPERATION,
                    new { TenantId = loginDTO.ClientId },
                    cancellationToken: ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.GetFetchingMessge));
            }
        }

        public async Task<IEnumerable<GopTargetOperationDTO>> GetListByEntityCode(
            string entityCode, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.QueryAsync<GopTargetOperationDTO>(
                    loginDTO,
                    GopTargetOperationQB.GET_LIST_BY_ENTITY_CODE,
                    new { TenantId = loginDTO.ClientId, EntityCode = entityCode },
                    cancellationToken: ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.GetFetchingMessge));
            }
        }

        public async Task Save(
            GopTargetOperationDTO dto, LoginDTO loginDTO, DbTransaction tx, CancellationToken ct = default)
        {
            try
            {
                dto.TenantId     = loginDTO.ClientId;
                dto.CreatedById  = loginDTO.UserId;
                dto.ModifiedById = loginDTO.UserId;

                await _QueryExecutor.ExecuteAsync(
                    loginDTO,
                    GopTargetOperationQB.SAVE,
                    new
                    {
                        dto.TargetOperationId,
                        dto.TenantId,
                        dto.OperationCode,
                        dto.OperationName,
                        dto.BaseUrl,
                        dto.RelativePath,
                        dto.HttpMethod,
                        dto.RequestSchemaJson,
                        dto.ResponseSchemaJson,
                        dto.SpecHash,
                        dto.EntityCode,
                        dto.IdFieldName,
                        dto.SortOrder,
                        dto.CreatedById,
                        dto.ModifiedById
                    },
                    tx, ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.SaveErrorMessage));
            }
        }

        public async Task Update(
            GopTargetOperationDTO dto, LoginDTO loginDTO, DbTransaction tx, CancellationToken ct = default)
        {
            try
            {
                dto.TenantId     = loginDTO.ClientId;
                dto.ModifiedById = loginDTO.UserId;

                await _QueryExecutor.ExecuteAsync(
                    loginDTO,
                    GopTargetOperationQB.UPDATE,
                    new
                    {
                        dto.TargetOperationId,
                        dto.TenantId,
                        dto.OperationName,
                        dto.BaseUrl,
                        dto.RelativePath,
                        dto.HttpMethod,
                        dto.RequestSchemaJson,
                        dto.ResponseSchemaJson,
                        dto.SpecHash,
                        dto.EntityCode,
                        dto.IdFieldName,
                        dto.SortOrder,
                        dto.ModifiedById
                    },
                    tx, ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.SaveErrorMessage));
            }
        }

        public async Task Delete(
            int targetOperationId, LoginDTO loginDTO, DbTransaction tx, CancellationToken ct = default)
        {
            try
            {
                await _QueryExecutor.ExecuteAsync(
                    loginDTO,
                    GopTargetOperationQB.DELETE,
                    new { TenantId = loginDTO.ClientId, TargetOperationId = targetOperationId, ModifiedById = loginDTO.UserId },
                    tx, ct);
            }
            catch (Exception ex)
            {
                throw new Exception(await _Validation.HandleException(ex, ErrorResponse.SaveErrorMessage));
            }
        }
    }
}