using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using GB5Shared.QueryExecutor;
using FrameworkDAL.DTO.EventLog;
using FrameworkDAL.Query.EventLog;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.Validation;
using GB5Shared.Resource.Response;
using Newtonsoft.Json;
using static GB5Shared.GB5Constant.Constant;

namespace FrameworkDAL.CustomCode.EventLog
{
    public class EventLogDAL : IEventLogDAL
    {
        private readonly IQueryExecutor _QueryExecutor;
        private readonly IValidation _Validation;
        public EventLogDAL(IQueryExecutor IQueryExecutor, IValidation IValidation)
        {
            _QueryExecutor = IQueryExecutor;
            _Validation = IValidation;
        }


        public async Task<string> GetEventLog(int EventLogId, LoginDTO LoginDTO)
        {
            try
            {
                string sql = EventLogQB.GET_EVENTLOG;
                var parameters = new { eventlogid = EventLogId};
                EventLogDTO EventLogDTO = await _QueryExecutor.QuerySingleAsync<EventLogDTO>(LoginDTO, sql, parameters);
                return JsonConvert.SerializeObject(EventLogDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task<string> SaveEventLog(EventLogDTO EventLogDTO ,LoginDTO LoginDTO)
        {
            try
            {
                string SQL = EventLogQB.SAVE_EVENTLOG;
                await _QueryExecutor.QueryAsync<EventLogDTO>(LoginDTO,SQL, EventLogDTO);
                return "EventLog Saved Successfully";
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<int> UpdateEventLog(EventLogDTO EventLogDTO, LoginDTO LoginDTO)
        {
            try
            {
                string Sql = EventLogQB.UPDATE_EVENTLOG;
                return await _QueryExecutor.ExecuteAsync(LoginDTO, Sql, EventLogDTO);
            }
            catch (Exception ex)
            {
                string Error = await _Validation.HandleException(ex, $"{ErrorResponse.UpdateErrorMessage}");
                throw new Exception(Error);
            }
        }
        public async Task<string> DeleteEventLog(int EventLogId, LoginDTO LoginDTO)
        {
            try
            {
                string Sql = EventLogQB.DELETE_EVENTLOG;
                var Parameters = new { eventlogid = EventLogId };
                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);
            }
        }

        /// <inheritdoc/>
        public async Task<int> SaveLoginEventLog(EventLogDTO eventLogDTO, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                // Select dialect-appropriate SQL: SQL Server uses OUTPUT Inserted.EVENTLOGID,
                // PostgreSQL uses RETURNING EVENTLOGID. Both return the new EVENTLOGID scalar.
                string sql = loginDTO.DatabaseType == DBTYPE.POSTGRESQL
                    ? EventLogQB.SAVE_LOGIN_EVENTLOG_POSTGRESQL
                    : EventLogQB.SAVE_LOGIN_EVENTLOG_SQL;

                return await _QueryExecutor.ExecuteScalarAsync<int>(loginDTO, sql, eventLogDTO, cancellationToken: ct);
            }
            catch (Exception)
            {
                throw;
            }
        }
    }
}