using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;
using Newtonsoft.Json;
using SkillManagementDAL.DTO.SkillDomain;
using SkillManagementDAL.Query.SkillDomain;

namespace SkillManagementDAL.CustomCode.SkillDomain
{
    public class SkillDomainDAL : ISkillDomainDAL
    {
        private readonly IQueryExecutor _qe;
        private readonly IValidation _Validation;

        public SkillDomainDAL(IQueryExecutor qe, IValidation validation)
        {
            _qe = qe;
            _Validation = validation;
        }

        public async Task<string> GetList(LoginDTO login, CancellationToken ct)
        {
            var result = await _qe.QueryAsync<SkillDomainDTO>(
                login, SkillDomainQB.GET_LIST,
                new { TenantId = login.ClientId });
            return JsonConvert.SerializeObject(result);
        }

        public async Task<string> GetById(int domainId, LoginDTO login, CancellationToken ct)
        {
            var result = await _qe.QuerySingleAsync<SkillDomainDTO>(
                login, SkillDomainQB.GET_BY_ID,
                new { DomainId = domainId, TenantId = login.ClientId });
            return JsonConvert.SerializeObject(result);
        }

        public async Task<string> GetSelectList(CriteriaDTO criteriaDTO, LoginDTO login, CancellationToken ct)
        {
            var result = await _qe.QueryWithCriteriaAsync<dynamic>(
                login, SkillDomainQB.GET_SELECT_LIST,
                new { TenantId = login.ClientId }, criteriaDTO, ct);
            return JsonConvert.SerializeObject(result);
        }

        public async Task<int> Insert(SkillDomainDTO dto, LoginDTO login, CancellationToken ct)
        {
            return await _qe.ExecuteAsync(
                login, SkillDomainQB.INSERT, dto);
        }

        public async Task<int> Update(SkillDomainDTO dto, LoginDTO login, CancellationToken ct)
        {
            return await _qe.ExecuteAsync(
                login, SkillDomainQB.UPDATE, dto);
        }

        //public async Task<int> SoftDelete(int domainId, int modifiedById, LoginDTO login, CancellationToken ct)
        //{
        //    return await _qe.ExecuteAsync(
        //        login, SkillDomainQB.SOFT_DELETE,
        //        new { DomainId = domainId, ModifiedById = modifiedById, TenantId = login.ClientId });
        //}

        //public async Task<int> CheckInUse(int domainId, LoginDTO login, CancellationToken ct)
        //{
        //    return await _qe.ExecuteScalarAsync<int>(
        //        login, SkillDomainQB.CHECK_IN_USE,
        //        new { DomainId = domainId });
        //}

        public async Task<string> DeleteSkillDomain(int domainId, LoginDTO loginDTO)
        {
            try
            {
                string sql = SkillDomainQB.DELETE_SKILL_DOMAIN;

                var parameter = new { DomainId = domainId }; // must match SQL parameter

                var result = await _qe.ExecuteAsync(loginDTO, sql, parameter);

                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);
            }
        }

    }
}