using System.Collections.Concurrent;
using System.Collections.Generic;
using StellaOps.Scheduler.Models;

namespace StellaOps.Scheduler.WebService.GraphJobs;

internal sealed class InMemoryGraphJobStore : IGraphJobStore
{
    private readonly ConcurrentDictionary<string, GraphBuildJob> _buildJobs = new(StringComparer.Ordinal);
    private readonly ConcurrentDictionary<string, GraphOverlayJob> _overlayJobs = new(StringComparer.Ordinal);

    public ValueTask<GraphBuildJob> AddAsync(GraphBuildJob job, CancellationToken cancellationToken)
    {
        _buildJobs[job.Id] = job;
        return ValueTask.FromResult(job);
    }

    public ValueTask<GraphOverlayJob> AddAsync(GraphOverlayJob job, CancellationToken cancellationToken)
    {
        _overlayJobs[job.Id] = job;
        return ValueTask.FromResult(job);
    }

    public ValueTask<GraphJobCollection> GetJobsAsync(string tenantId, GraphJobQuery query, CancellationToken cancellationToken)
    {
        var normalized = query.Normalize();
        var buildJobs = _buildJobs.Values
            .Where(job => string.Equals(job.TenantId, tenantId, StringComparison.Ordinal))
            .Where(job => normalized.Status is null || job.Status == normalized.Status)
            .OrderByDescending(job => job.CreatedAt)
            .Take(normalized.Limit ?? 50)
            .ToArray();

        var overlayJobs = _overlayJobs.Values
            .Where(job => string.Equals(job.TenantId, tenantId, StringComparison.Ordinal))
            .Where(job => normalized.Status is null || job.Status == normalized.Status)
            .OrderByDescending(job => job.CreatedAt)
            .Take(normalized.Limit ?? 50)
            .ToArray();

        return ValueTask.FromResult(GraphJobCollection.From(buildJobs, overlayJobs));
    }

    public ValueTask<GraphBuildJob?> GetBuildJobAsync(string tenantId, string jobId, CancellationToken cancellationToken)
    {
        if (_buildJobs.TryGetValue(jobId, out var job) && string.Equals(job.TenantId, tenantId, StringComparison.Ordinal))
        {
            return ValueTask.FromResult<GraphBuildJob?>(job);
        }

        return ValueTask.FromResult<GraphBuildJob?>(null);
    }

    public ValueTask<GraphOverlayJob?> GetOverlayJobAsync(string tenantId, string jobId, CancellationToken cancellationToken)
    {
        if (_overlayJobs.TryGetValue(jobId, out var job) && string.Equals(job.TenantId, tenantId, StringComparison.Ordinal))
        {
            return ValueTask.FromResult<GraphOverlayJob?>(job);
        }

        return ValueTask.FromResult<GraphOverlayJob?>(null);
    }

    public ValueTask<GraphJobUpdateResult<GraphBuildJob>> UpdateAsync(GraphBuildJob job, GraphJobStatus expectedStatus, CancellationToken cancellationToken)
    {
        if (_buildJobs.TryGetValue(job.Id, out var existing) && string.Equals(existing.TenantId, job.TenantId, StringComparison.Ordinal))
        {
            if (existing.Status == expectedStatus)
            {
                _buildJobs[job.Id] = job;
                return ValueTask.FromResult(GraphJobUpdateResult<GraphBuildJob>.UpdatedResult(job));
            }

            return ValueTask.FromResult(GraphJobUpdateResult<GraphBuildJob>.NotUpdated(existing));
        }

        throw new KeyNotFoundException($"Graph build job '{job.Id}' not found.");
    }

    public ValueTask<GraphJobUpdateResult<GraphOverlayJob>> UpdateAsync(GraphOverlayJob job, GraphJobStatus expectedStatus, CancellationToken cancellationToken)
    {
        if (_overlayJobs.TryGetValue(job.Id, out var existing) && string.Equals(existing.TenantId, job.TenantId, StringComparison.Ordinal))
        {
            if (existing.Status == expectedStatus)
            {
                _overlayJobs[job.Id] = job;
                return ValueTask.FromResult(GraphJobUpdateResult<GraphOverlayJob>.UpdatedResult(job));
            }

            return ValueTask.FromResult(GraphJobUpdateResult<GraphOverlayJob>.NotUpdated(existing));
        }

        throw new KeyNotFoundException($"Graph overlay job '{job.Id}' not found.");
    }

    public ValueTask<IReadOnlyCollection<GraphOverlayJob>> GetOverlayJobsAsync(string tenantId, CancellationToken cancellationToken)
    {
        var jobs = _overlayJobs.Values
            .Where(job => string.Equals(job.TenantId, tenantId, StringComparison.Ordinal))
            .ToArray();

        return ValueTask.FromResult<IReadOnlyCollection<GraphOverlayJob>>(jobs);
    }
}