using ClaudeDo.Data.Models;
using ClaudeDo.Data.Repositories;
using ClaudeDo.Worker.Tests.Infrastructure;

namespace ClaudeDo.Worker.Tests.Repositories;

public class PrimeScheduleRepositoryTests : IDisposable
{
    private readonly DbFixture _db = new();
    public void Dispose() => _db.Dispose();

    private static PrimeScheduleEntity Row(PrimeActionKind kind) => new()
    {
        Id = Guid.NewGuid(),
        Days = PrimeDays.Weekdays,
        TimeOfDay = new TimeSpan(7, 0, 0),
        Enabled = true,
        Kind = kind,
    };

    [Fact]
    public async Task Upsert_Then_List_RoundTrips()
    {
        var id = Guid.NewGuid();
        using (var ctx = _db.CreateContext())
        {
            await new PrimeScheduleRepository(ctx).UpsertAsync(new PrimeScheduleEntity
            {
                Id = id,
                Days = PrimeDays.Weekdays,
                TimeOfDay = new TimeSpan(7, 0, 0),
                Enabled = true,
                CreatedAt = DateTimeOffset.UtcNow,
            });
        }

        using var read = _db.CreateContext();
        var rows = await new PrimeScheduleRepository(read).ListAsync();
        Assert.Single(rows);
        Assert.Equal(id, rows[0].Id);
        Assert.Equal(new TimeSpan(7, 0, 0), rows[0].TimeOfDay);
        Assert.Equal(PrimeDays.Weekdays, rows[0].Days);
    }

    [Fact]
    public async Task UpdateLastRunAt_Persists()
    {
        var id = Guid.NewGuid();
        var when = new DateTimeOffset(2026, 5, 5, 7, 1, 0, TimeSpan.FromHours(2));
        using (var ctx = _db.CreateContext())
        {
            await new PrimeScheduleRepository(ctx).UpsertAsync(new PrimeScheduleEntity
            {
                Id = id,
                Days = PrimeDays.Weekdays,
                TimeOfDay = new TimeSpan(7, 0, 0),
                Enabled = true,
                CreatedAt = DateTimeOffset.UtcNow,
            });
        }
        using (var ctx = _db.CreateContext())
            await new PrimeScheduleRepository(ctx).UpdateLastRunAsync(id, when);

        using var read = _db.CreateContext();
        var row = await new PrimeScheduleRepository(read).GetAsync(id);
        Assert.NotNull(row);
        Assert.Equal(when, row!.LastRunAt);
    }

    [Fact]
    public async Task Delete_Removes_Row()
    {
        var id = Guid.NewGuid();
        using (var ctx = _db.CreateContext())
            await new PrimeScheduleRepository(ctx).UpsertAsync(new PrimeScheduleEntity
            {
                Id = id,
                Days = PrimeDays.All,
                TimeOfDay = TimeSpan.Zero,
                Enabled = true,
                CreatedAt = DateTimeOffset.UtcNow,
            });
        using (var ctx = _db.CreateContext())
            await new PrimeScheduleRepository(ctx).DeleteAsync(id);

        using var read = _db.CreateContext();
        Assert.Empty(await new PrimeScheduleRepository(read).ListAsync());
    }

    [Fact]
    public void Kind_defaults_to_ping_on_a_new_entity()
    {
        Assert.Equal(PrimeActionKind.Ping, new PrimeScheduleEntity().Kind);
    }

    [Fact]
    public async Task Kind_round_trips_through_the_database()
    {
        using var ctx = _db.CreateContext();
        var repo = new PrimeScheduleRepository(ctx);
        var row = Row(PrimeActionKind.Custom);

        await repo.UpsertAsync(row);
        var reloaded = await repo.GetAsync(row.Id);

        Assert.NotNull(reloaded);
        Assert.Equal(PrimeActionKind.Custom, reloaded!.Kind);
    }

    [Fact]
    public async Task UpsertAsync_updates_kind_on_an_existing_row()
    {
        using var ctx = _db.CreateContext();
        var repo = new PrimeScheduleRepository(ctx);
        var row = Row(PrimeActionKind.Ping);
        await repo.UpsertAsync(row);

        await repo.UpsertAsync(new PrimeScheduleEntity
        {
            Id = row.Id,
            Days = row.Days,
            TimeOfDay = row.TimeOfDay,
            Enabled = row.Enabled,
            Kind = PrimeActionKind.FillMyDay,
        });

        var reloaded = await repo.GetAsync(row.Id);
        Assert.Equal(PrimeActionKind.FillMyDay, reloaded!.Kind);
    }
}