using Dapper;
using GestionIntegral.Api.Models.Radios;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace GestionIntegral.Api.Data.Repositories.Radios
{
    public class RitmoRepository : IRitmoRepository
    {
        private readonly DbConnectionFactory _cf;
        private readonly ILogger<RitmoRepository> _log;

        public RitmoRepository(DbConnectionFactory cf, ILogger<RitmoRepository> log)
        {
            _cf = cf;
            _log = log;
        }

        public async Task<IEnumerable<Ritmo>> GetAllAsync(string? nombreFilter)
        {
            var sqlBuilder = new StringBuilder("SELECT Id, Ritmo AS NombreRitmo FROM dbo.rad_dtRitmos WHERE 1=1");
            var parameters = new DynamicParameters();
            if (!string.IsNullOrWhiteSpace(nombreFilter))
            {
                sqlBuilder.Append(" AND Ritmo LIKE @NombreFilterParam");
                parameters.Add("NombreFilterParam", $"%{nombreFilter}%");
            }
            sqlBuilder.Append(" ORDER BY Ritmo;");
            try
            {
                using var connection = _cf.CreateConnection();
                return await connection.QueryAsync<Ritmo>(sqlBuilder.ToString(), parameters);
            }
            catch (Exception ex)
            {
                _log.LogError(ex, "Error al obtener todos los Ritmos.");
                return Enumerable.Empty<Ritmo>();
            }
        }

        public async Task<Ritmo?> GetByIdAsync(int id)
        {
            const string sql = "SELECT Id, Ritmo AS NombreRitmo FROM dbo.rad_dtRitmos WHERE Id = @IdParam";
            try
            {
                using var connection = _cf.CreateConnection();
                return await connection.QuerySingleOrDefaultAsync<Ritmo>(sql, new { IdParam = id });
            }
            catch (Exception ex)
            {
                _log.LogError(ex, "Error al obtener Ritmo por ID: {IdRitmo}", id);
                return null;
            }
        }

        public async Task<bool> ExistsByNameAsync(string nombreRitmo, int? excludeId = null)
        {
            var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.rad_dtRitmos WHERE Ritmo = @NombreRitmoParam");
            var parameters = new DynamicParameters();
            parameters.Add("NombreRitmoParam", nombreRitmo);
            if (excludeId.HasValue)
            {
                sqlBuilder.Append(" AND Id != @ExcludeIdParam");
                parameters.Add("ExcludeIdParam", excludeId.Value);
            }
            try
            {
                using var connection = _cf.CreateConnection();
                return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
            }
            catch (Exception ex)
            {
                _log.LogError(ex, "Error en ExistsByNameAsync para Ritmo: {NombreRitmo}", nombreRitmo);
                return true;
            }
        }

        public async Task<bool> IsInUseAsync(int id)
        {
            const string sql = "SELECT TOP 1 1 FROM dbo.rad_dtCanciones WHERE Ritmo = @IdParam"; // Columna 'Ritmo' en Canciones es FK a 'Id' en Ritmos
            try
            {
                using var connection = _cf.CreateConnection();
                return await connection.ExecuteScalarAsync<bool>(sql, new { IdParam = id });
            }
            catch (Exception ex)
            {
                 _log.LogError(ex, "Error en IsInUseAsync para Ritmo ID: {IdRitmo}", id);
                return true;
            }
        }

        public async Task<Ritmo?> CreateAsync(Ritmo nuevoRitmo /*, int idUsuario, IDbTransaction transaction */)
        {
            // Sin historial, no se necesita transacción aquí para una sola inserción.
            const string sqlInsert = @"
                INSERT INTO dbo.rad_dtRitmos (Ritmo)
                OUTPUT INSERTED.Id, INSERTED.Ritmo AS NombreRitmo
                VALUES (@NombreRitmo);";
            try
            {
                using var connection = _cf.CreateConnection();
                return await connection.QuerySingleAsync<Ritmo>(sqlInsert, nuevoRitmo);
            }
            catch(Exception ex)
            {
                _log.LogError(ex, "Error al crear Ritmo: {NombreRitmo}", nuevoRitmo.NombreRitmo);
                return null;
            }
        }

        public async Task<bool> UpdateAsync(Ritmo ritmoAActualizar /*, int idUsuario, IDbTransaction transaction */)
        {
            const string sqlUpdate = "UPDATE dbo.rad_dtRitmos SET Ritmo = @NombreRitmo WHERE Id = @Id;";
            try
            {
                using var connection = _cf.CreateConnection();
                var rowsAffected = await connection.ExecuteAsync(sqlUpdate, ritmoAActualizar);
                return rowsAffected == 1;
            }
            catch(Exception ex)
            {
                _log.LogError(ex, "Error al actualizar Ritmo ID: {IdRitmo}", ritmoAActualizar.Id);
                return false;
            }
        }

        public async Task<bool> DeleteAsync(int id /*, int idUsuario, IDbTransaction transaction */)
        {
            const string sqlDelete = "DELETE FROM dbo.rad_dtRitmos WHERE Id = @IdParam";
            try
            {
                using var connection = _cf.CreateConnection();
                var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { IdParam = id });
                return rowsAffected == 1;
            }
            catch(Exception ex)
            {
                _log.LogError(ex, "Error al eliminar Ritmo ID: {IdRitmo}", id);
                return false;
            }
        }
    }
}