using FrameworkDAL.DTO.PatternCore;
using FrameworkDAL.Query.PatternCore;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using static iText.Kernel.Pdf.Colorspace.PdfSpecialCs;

namespace FrameworkDAL.CustomCode.PatternCore
{
    public class PatternCoreDAL : IPatternCoreDAL
    {
        private readonly IQueryExecutor _QueryExecutor;
        private readonly IValidation _Validation;
        public PatternCoreDAL(IQueryExecutor IQueryExecutor, IValidation IValidation)
        {
            _QueryExecutor = IQueryExecutor;
            _Validation = IValidation;
        }

        public async Task<string> GetPatternCore(int PatternCoreId, LoginDTO LoginDTO)
        {
            try
            {
                string sql = PatternCoreQB.GET_PATTERNCORE;
                var parameters = new { patterncoreid = PatternCoreId };
                PatternCoreDTO PatternCoreDTO = await _QueryExecutor.QuerySingleAsync<PatternCoreDTO>(LoginDTO, sql, parameters);
                return JsonConvert.SerializeObject(PatternCoreDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetPatternCoreList(CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                string SQL = PatternCoreQB.GET_PATTERNCORE_LIST;
                var Result = await _QueryExecutor.QueryAsync<PatternCoreDTO>(LoginDTO, SQL, null!);
                string Json = JsonConvert.SerializeObject(Result);
                return Json;
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task<int> SavePatternCore(PatternCoreDTO PatternCoreDTO, LoginDTO LoginDTO)
        {
            try
            {
                string Sql = PatternCoreQB.SAVE_PATTERNCORE;
                return await _QueryExecutor.ExecuteAsync(LoginDTO, Sql, PatternCoreDTO);
            }
            catch (Exception ex)
            {
                string Error = await _Validation.HandleException(ex, $"{ErrorResponse.SaveErrorMessage}");
                throw new Exception(Error);
            }
        }

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

        public async Task<string> DeletePatternCore(int PatternCoreId, LoginDTO LoginDTO)
        {
            try
            {
                string Sql = PatternCoreQB.DELETE_PATTERNCORE;
                var Parameters = new { patterncoreid = PatternCoreId };
                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);
            }
        }

        public async Task<List<PatternCorePicklistDTO>> GetSelectListPatternCore(int FirstNumber, int MaxResult, CriteriaDTO CriteriaDTO, LoginDTO LoginDTO, bool IsCount = false)
        {
            try
            {
                var parameters = new
                {
                    Code = GetCode(CriteriaDTO),
                    FirstNumber = FirstNumber,
                    MaxResult = MaxResult
                };

                var result = await _QueryExecutor.QueryAsync<PatternCorePicklistDTO>(LoginDTO, PatternCoreQB.GET_SELECTLIST_PATTERNCORE, parameters);
                return result.ToList();
            }
            catch (Exception)
            {
                throw;
            }
        }

        private string GetCode(CriteriaDTO criteriaDTO)
        {
            try
            {
                var attribute = criteriaDTO?.SectionCriteriaList?
                    .SelectMany(x => x.AttributesCriteriaList)
                    .FirstOrDefault(x => x.FieldName == "Code");

                return attribute?.FieldValue?.ToString();
            }
            catch
            {
                return null;
            }
        }

        //private string? GetCode(CriteriaDTO criteriaDTO)
        //{
        //    var value = criteriaDTO?.SectionCriteriaList?
        //        .SelectMany(s => s.AttributesCriteriaList)
        //        .FirstOrDefault(x => x.FieldName == "Code")?.FieldValue;

        //    if (value == null)
        //        return null;

        //    if (value is JsonElement element)
        //    {
        //        if (element.ValueKind == JsonValueKind.String)
        //            return element.GetString();

        //        if (element.ValueKind == JsonValueKind.Number)
        //            return element.GetInt32().ToString();
        //    }

        //    return Convert.ToString(value);
        //}
    }
}