using Health.Application.AI;
using Health.Application.Calendars;
using Health.Application.HealthArchives;
using Health.Application.HealthRecords;
using Health.Application.Exercises;
using Health.Domain.Entities;
using Health.Domain.Enums;

namespace Health.Tests;

public sealed class ApplicationServiceTests
{
    [Fact]
    public async Task HealthArchive_AiUpdate_OnlyChangesRequestedSection()
    {
        var userId = Guid.NewGuid();
        var repository = new FakeHealthArchiveRepository(new HealthArchive
        {
            Id = Guid.NewGuid(),
            UserId = userId,
            Diagnosis = "原诊断",
            Allergies = ["青霉素"]
        });
        var service = new HealthArchiveService(repository);

        var result = await service.ExecuteAiActionAsync(
            userId,
            "update_diagnosis",
            new HealthArchiveUpdateRequest("新诊断", "不应写入的手术", null, null, null, null, null),
            CancellationToken.None);

        Assert.True((bool)result.GetType().GetProperty("success")!.GetValue(result)!);
        Assert.Equal("新诊断", repository.Archive!.Diagnosis);
        Assert.Null(repository.Archive.SurgeryType);
        Assert.Equal(["青霉素"], repository.Archive.Allergies);
    }

    [Fact]
    public async Task HealthArchive_ManualUpdateStoresMultipleStructuredSurgeries()
    {
        var userId = Guid.NewGuid();
        var repository = new FakeHealthArchiveRepository(new HealthArchive
        {
            Id = Guid.NewGuid(), UserId = userId,
        });
        var service = new HealthArchiveService(repository);

        var result = await service.UpdateAsync(
            userId,
            new HealthArchiveUpdateRequest(
                null, null, null, null, null, null, null,
                [
                    new HealthArchiveSurgeryInput("PCI", new DateOnly(2025, 3, 1)),
                    new HealthArchiveSurgeryInput("Appendectomy", new DateOnly(2010, 6, 2)),
                ]),
            CancellationToken.None);

        Assert.Equal(2, result.Surgeries.Count);
        Assert.Equal("PCI", result.SurgeryType);
        Assert.Equal(new DateOnly(2025, 3, 1), result.SurgeryDate);
        Assert.Equal([0, 1], repository.Archive!.Surgeries.OrderBy(s => s.SortOrder).Select(s => s.SortOrder));
    }

    [Fact]
    public async Task HealthTrend_365DaysUsesFullYearWindow()
    {
        var repository = new CapturingHealthRecordRepository();
        var service = new HealthRecordService(repository);
        var before = DateTime.UtcNow;

        await service.GetTrendAsync(Guid.NewGuid(), HealthMetricType.Weight, 365, CancellationToken.None);

        Assert.NotNull(repository.RecordedAfter);
        Assert.InRange((before - repository.RecordedAfter!.Value).TotalDays, 364.99, 365.01);
    }

    [Fact]
    public async Task HealthArchive_AiSurgeryUpdatePreservesLegacySurgery()
    {
        var userId = Guid.NewGuid();
        var repository = new FakeHealthArchiveRepository(new HealthArchive
        {
            Id = Guid.NewGuid(), UserId = userId,
            SurgeryType = "Legacy surgery", SurgeryDate = new DateOnly(2010, 1, 2),
        });
        var service = new HealthArchiveService(repository);

        await service.ExecuteAiActionAsync(
            userId,
            "update_surgery",
            new HealthArchiveUpdateRequest(null, "New surgery", new DateOnly(2026, 6, 20), null, null, null, null),
            CancellationToken.None);

        Assert.Equal(2, repository.Archive!.Surgeries.Count);
        Assert.Contains(repository.Archive.Surgeries, s => s.Type == "Legacy surgery");
        Assert.Contains(repository.Archive.Surgeries, s => s.Type == "New surgery");
    }

    [Fact]
    public async Task Conversation_Open_DoesNotReturnAnotherUsersConversation()
    {
        var ownerId = Guid.NewGuid();
        var conversation = new Conversation { Id = Guid.NewGuid(), UserId = ownerId, AgentType = AgentType.Health };
        var service = new AiConversationService(new FakeConversationRepository(conversation));

        var result = await service.OpenAsync(Guid.NewGuid(), conversation.Id, AgentType.Health, "测试", CancellationToken.None);

        Assert.False(result.Found);
        Assert.False(result.Created);
    }

    [Fact]
    public async Task Calendar_Month_AggregatesMedicationExerciseAndFollowUp()
    {
        var date = new DateOnly(2026, 6, 19);
        var medication = new Medication
        {
            Id = Guid.NewGuid(), IsActive = true, Name = "阿司匹林", StartDate = date.AddDays(-1), TimeOfDay = [new TimeOnly(8, 0)]
        };
        var plan = new ExercisePlan { Id = Guid.NewGuid(), StartDate = date, EndDate = date, ReminderTime = new TimeOnly(19, 0) };
        plan.Items.Add(new ExercisePlanItem { Id = Guid.NewGuid(), ScheduledDate = date, ExerciseType = "散步", DurationMinutes = 30 });
        var followUp = new FollowUp { Id = Guid.NewGuid(), ScheduledAt = date.ToDateTime(new TimeOnly(9, 0)), Title = "复查" };
        var service = new CalendarService(new FakeCalendarRepository(new CalendarDataSnapshot([medication], [plan], [followUp])));

        var result = await service.GetMonthAsync(Guid.NewGuid(), 2026, 6, CancellationToken.None);

        var target = Assert.Single(result, item =>
            item.GetType().GetProperty("date")!.GetValue(item)?.ToString() == "2026-06-19");
        var events = (IEnumerable<string>)target.GetType().GetProperty("events")!.GetValue(target)!;
        Assert.Equal(["medication", "exercise", "followup"], events);
    }

    [Fact]
    public async Task ExercisePlan_TenDays_CreatesTenUniqueConsecutiveDates()
    {
        var repository = new FakeExerciseRepository();
        var service = new ExerciseService(repository);
        var start = new DateOnly(2026, 6, 20);

        await service.CreateAsync(Guid.NewGuid(), new ExercisePlanCreateRequest(start, start.AddDays(9), "跑步", 30, new TimeOnly(19, 0)), CancellationToken.None);

        var plan = Assert.IsType<ExercisePlan>(repository.Plan);
        Assert.Equal(start.AddDays(9), plan.EndDate);
        Assert.Equal(10, plan.Items.Count);
        Assert.Equal(10, plan.Items.Select(x => x.ScheduledDate).Distinct().Count());
        Assert.Equal(Enumerable.Range(0, 10).Select(start.AddDays), plan.Items.OrderBy(x => x.ScheduledDate).Select(x => x.ScheduledDate));
    }

    [Fact]
    public async Task ExercisePlan_CurrentUsesExactScheduledDate()
    {
        var today = DateOnly.FromDateTime(DateTime.UtcNow.AddHours(8));
        var repository = new FakeExerciseRepository();
        var plan = new ExercisePlan
        {
            Id = Guid.NewGuid(), UserId = Guid.NewGuid(), StartDate = today, EndDate = today.AddDays(9), ReminderTime = new TimeOnly(19, 0),
        };
        plan.Items.Add(new ExercisePlanItem { Id = Guid.NewGuid(), ScheduledDate = today, ExerciseType = "跑步", DurationMinutes = 30 });
        plan.Items.Add(new ExercisePlanItem { Id = Guid.NewGuid(), ScheduledDate = today.AddDays(7), ExerciseType = "跑步", DurationMinutes = 30 });
        repository.SetPlan(plan);
        var service = new ExerciseService(repository);

        var current = await service.GetCurrentAsync(plan.UserId, CancellationToken.None);

        Assert.NotNull(current);
        Assert.Equal(today, current!.Items.Single(x => x.ScheduledDate == today).ScheduledDate);
        Assert.Equal(2, current.Items.Count);
    }

    private sealed class FakeHealthArchiveRepository(HealthArchive? archive) : IHealthArchiveRepository
    {
        public HealthArchive? Archive { get; private set; } = archive;
        public Task<HealthArchive?> GetByUserIdAsync(Guid userId, CancellationToken ct) => Task.FromResult(Archive?.UserId == userId ? Archive : null);
        public Task AddAsync(HealthArchive value, CancellationToken ct) { Archive = value; return Task.CompletedTask; }
        public Task SaveChangesAsync(CancellationToken ct) => Task.CompletedTask;
    }

    private sealed class CapturingHealthRecordRepository : IHealthRecordRepository
    {
        public DateTime? RecordedAfter { get; private set; }
        public Task<IReadOnlyList<HealthRecord>> ListAsync(Guid userId, HealthMetricType? type, DateTime? recordedAfter, int limit, CancellationToken ct) =>
            Task.FromResult<IReadOnlyList<HealthRecord>>([]);
        public Task<HealthRecord?> GetOwnedAsync(Guid userId, Guid id, CancellationToken ct) => Task.FromResult<HealthRecord?>(null);
        public Task<HealthRecord?> GetLatestByTypeAsync(Guid userId, HealthMetricType type, CancellationToken ct) => Task.FromResult<HealthRecord?>(null);
        public Task<IReadOnlyList<HealthRecord>> GetTrendAsync(Guid userId, HealthMetricType type, DateTime recordedAfter, CancellationToken ct)
        {
            RecordedAfter = recordedAfter;
            return Task.FromResult<IReadOnlyList<HealthRecord>>([]);
        }
        public Task AddAsync(HealthRecord record, CancellationToken ct) => Task.CompletedTask;
        public void Delete(HealthRecord record) { }
        public Task SaveChangesAsync(CancellationToken ct) => Task.CompletedTask;
    }

    private sealed class FakeConversationRepository(Conversation conversation) : IAiConversationRepository
    {
        private readonly Conversation _conversation = conversation;
        public Task<Conversation?> GetOwnedAsync(Guid userId, Guid conversationId, CancellationToken ct) => Task.FromResult(_conversation.Id == conversationId && _conversation.UserId == userId ? _conversation : null);
        public Task<Conversation?> GetAsync(Guid conversationId, CancellationToken ct) => Task.FromResult(_conversation.Id == conversationId ? _conversation : null);
        public Task<IReadOnlyList<Conversation>> ListAsync(Guid userId, CancellationToken ct) => Task.FromResult<IReadOnlyList<Conversation>>([]);
        public Task<IReadOnlyList<ConversationMessage>> GetMessagesAsync(Guid conversationId, CancellationToken ct) => Task.FromResult<IReadOnlyList<ConversationMessage>>([]);
        public Task<IReadOnlyList<ConversationMessage>> GetRecentMessagesAsync(Guid conversationId, int limit, CancellationToken ct) => Task.FromResult<IReadOnlyList<ConversationMessage>>([]);
        public Task AddConversationAsync(Conversation value, CancellationToken ct) => Task.CompletedTask;
        public Task AddMessageAsync(ConversationMessage message, CancellationToken ct) => Task.CompletedTask;
        public void Delete(Conversation value) { }
        public Task SaveChangesAsync(CancellationToken ct) => Task.CompletedTask;
    }

    private sealed class FakeCalendarRepository(CalendarDataSnapshot snapshot) : ICalendarRepository
    {
        public Task<CalendarDataSnapshot> GetSnapshotAsync(Guid userId, DateOnly start, DateOnly end, CancellationToken ct) => Task.FromResult(snapshot);
    }

    private sealed class FakeExerciseRepository : IExerciseRepository
    {
        public ExercisePlan? Plan { get; private set; }
        public void SetPlan(ExercisePlan plan) => Plan = plan;
        public Task<IReadOnlyList<ExercisePlan>> ListActiveOnAsync(Guid userId, DateOnly date, CancellationToken ct) => Task.FromResult<IReadOnlyList<ExercisePlan>>(
            Plan != null && Plan.UserId == userId && Plan.StartDate <= date && Plan.EndDate >= date ? [Plan] : []);
        public Task<IReadOnlyList<ExercisePlan>> ListAsync(Guid userId, int limit, CancellationToken ct) => Task.FromResult<IReadOnlyList<ExercisePlan>>([]);
        public Task<ExercisePlan?> GetOwnedPlanAsync(Guid userId, Guid planId, CancellationToken ct) => Task.FromResult(Plan);
        public Task<ExercisePlan?> GetLatestAsync(Guid userId, CancellationToken ct) => Task.FromResult(Plan);
        public Task<ExercisePlanItem?> GetOwnedItemAsync(Guid userId, Guid itemId, CancellationToken ct) => Task.FromResult(Plan?.Items.FirstOrDefault(x => x.Id == itemId));
        public Task AddAsync(ExercisePlan plan, CancellationToken ct) { Plan = plan; return Task.CompletedTask; }
        public void Delete(ExercisePlan plan) { Plan = null; }
        public Task SaveChangesAsync(CancellationToken ct) => Task.CompletedTask;
    }
}
