using Microsoft.EntityFrameworkCore;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites;
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;

namespace ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Repositories;

/// <summary>
/// EF Core implementation of ISiteRepository for site and data connection management.
/// </summary>
public class SiteRepository : ISiteRepository
{
    private readonly ScadaBridgeDbContext _dbContext;

    /// <summary>
    /// Initializes a new instance of the SiteRepository.
    /// </summary>
    /// <param name="dbContext">The database context.</param>
    public SiteRepository(ScadaBridgeDbContext dbContext)
    {
        _dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
    }

    // --- Sites ---

    /// <inheritdoc />
    public async Task<Site?> GetSiteByIdAsync(int id, CancellationToken cancellationToken = default)
    {
        return await _dbContext.Sites.FindAsync([id], cancellationToken);
    }

    /// <inheritdoc />
    public async Task<Site?> GetSiteByIdentifierAsync(string siteIdentifier, CancellationToken cancellationToken = default)
    {
        return await _dbContext.Sites
            .FirstOrDefaultAsync(s => s.SiteIdentifier == siteIdentifier, cancellationToken);
    }

    /// <inheritdoc />
    public async Task<IReadOnlyList<Site>> GetAllSitesAsync(CancellationToken cancellationToken = default)
    {
        return await _dbContext.Sites.OrderBy(s => s.Name).ToListAsync(cancellationToken);
    }

    /// <inheritdoc />
    public async Task AddSiteAsync(Site site, CancellationToken cancellationToken = default)
    {
        await _dbContext.Sites.AddAsync(site, cancellationToken);
    }

    /// <inheritdoc />
    public Task UpdateSiteAsync(Site site, CancellationToken cancellationToken = default)
    {
        _dbContext.Sites.Update(site);
        return Task.CompletedTask;
    }

    /// <inheritdoc />
    public Task DeleteSiteAsync(int id, CancellationToken cancellationToken = default)
    {
        var entity = _dbContext.Sites.Local.FirstOrDefault(s => s.Id == id);
        if (entity != null)
        {
            _dbContext.Sites.Remove(entity);
        }
        else
        {
            var stub = new Site("stub", "stub") { Id = id };
            _dbContext.Sites.Attach(stub);
            _dbContext.Sites.Remove(stub);
        }
        return Task.CompletedTask;
    }

    // --- Data Connections ---

    /// <inheritdoc />
    public async Task<DataConnection?> GetDataConnectionByIdAsync(int id, CancellationToken cancellationToken = default)
    {
        return await _dbContext.DataConnections.FindAsync([id], cancellationToken);
    }

    /// <inheritdoc />
    public async Task<IReadOnlyList<DataConnection>> GetAllDataConnectionsAsync(CancellationToken cancellationToken = default)
    {
        return await _dbContext.DataConnections.OrderBy(c => c.Name).ToListAsync(cancellationToken);
    }

    /// <inheritdoc />
    public async Task<IReadOnlyList<DataConnection>> GetDataConnectionsBySiteIdAsync(int siteId, CancellationToken cancellationToken = default)
    {
        return await _dbContext.DataConnections
            .Where(c => c.SiteId == siteId)
            .OrderBy(c => c.Name)
            .ToListAsync(cancellationToken);
    }

    /// <inheritdoc />
    public async Task AddDataConnectionAsync(DataConnection connection, CancellationToken cancellationToken = default)
    {
        await _dbContext.DataConnections.AddAsync(connection, cancellationToken);
    }

    /// <inheritdoc />
    public Task UpdateDataConnectionAsync(DataConnection connection, CancellationToken cancellationToken = default)
    {
        _dbContext.DataConnections.Update(connection);
        return Task.CompletedTask;
    }

    /// <inheritdoc />
    public Task DeleteDataConnectionAsync(int id, CancellationToken cancellationToken = default)
    {
        var entity = _dbContext.DataConnections.Local.FirstOrDefault(c => c.Id == id);
        if (entity != null)
        {
            _dbContext.DataConnections.Remove(entity);
        }
        else
        {
            var stub = new DataConnection("stub", "stub", 0) { Id = id };
            _dbContext.DataConnections.Attach(stub);
            _dbContext.DataConnections.Remove(stub);
        }
        return Task.CompletedTask;
    }

    // --- Instances (for deletion / move constraint checks) ---

    /// <inheritdoc />
    public async Task<IReadOnlyList<Instance>> GetInstancesBySiteIdAsync(int siteId, CancellationToken cancellationToken = default)
    {
        return await _dbContext.Instances
            .Where(i => i.SiteId == siteId)
            .Include(i => i.ConnectionBindings)
            .Include(i => i.NativeAlarmSourceOverrides)
            .AsSplitQuery()
            .ToListAsync(cancellationToken);
    }

    /// <inheritdoc />
    public async Task<IReadOnlyList<Instance>> GetInstancesReferencingDataConnectionAsync(int dataConnectionId, CancellationToken cancellationToken = default)
    {
        // The distinct instance ids whose bindings reference the connection.
        // Bindings are not exposed via their own DbSet on ISiteRepository, so
        // resolve them through the InstanceConnectionBindings set, then load the
        // owning instances (cheap; the blocker list is expected to be tiny).
        var instanceIds = await _dbContext.InstanceConnectionBindings
            .Where(b => b.DataConnectionId == dataConnectionId)
            .Select(b => b.InstanceId)
            .Distinct()
            .ToListAsync(cancellationToken);

        if (instanceIds.Count == 0)
            return Array.Empty<Instance>();

        return await _dbContext.Instances
            .Where(i => instanceIds.Contains(i.Id))
            .ToListAsync(cancellationToken);
    }

    /// <inheritdoc />
    public async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
    {
        return await _dbContext.SaveChangesAsync(cancellationToken);
    }
}