using JobTrackerApi.Controllers;
using JobTrackerApi.Data;
using JobTrackerApi.Models;
using JobTrackerApi.Services;
using JobTrackerApi.Tests.TestSupport;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Moq;
using Xunit;

namespace JobTrackerApi.Tests;

public sealed class CorrespondenceControllerTests
{
    [Fact]
    public async Task Create_tags_manually_entered_correspondence_with_manual_provider()
    {
        await using var db = TestHostFactory.CreateInMemoryDb();
        var company = new Company { Name = "Acme", OwnerUserId = "user-1" };
        db.Companies.Add(company);
        await db.SaveChangesAsync();

        var job = new JobApplication { JobTitle = "Backend Developer", CompanyId = company.Id, OwnerUserId = "user-1" };
        db.JobApplications.Add(job);
        await db.SaveChangesAsync();

        var controller = new CorrespondenceController(db);
        var request = new CorrespondenceController.CreateCorrespondenceRequestV2(
            job.Id, "Me", "Called to follow up.", "Follow-up call", "Call", null, "outbound", null, null, null, null, null, null);

        var result = await controller.Create(request, CancellationToken.None);

        Assert.IsType<Correspondence>(((CreatedAtActionResult)result.Result!).Value);
        var stored = await db.Correspondences.SingleAsync();
        Assert.Equal("manual", stored.Provider);
    }

    [Fact]
    public async Task Message_detail_is_owner_scoped_and_tolerates_bad_metadata()
    {
        var databaseName = Guid.NewGuid().ToString();
        var options = new DbContextOptionsBuilder<JobTrackerContext>().UseInMemoryDatabase(databaseName).Options;
        var owner = new Mock<ICurrentUserService>();
        owner.SetupGet(service => service.UserId).Returns("user-1");

        int messageId;
        await using (var ownerDb = new JobTrackerContext(options, owner.Object))
        {
            var company = new Company { Name = "Acme", OwnerUserId = "user-1" };
            ownerDb.Companies.Add(company);
            await ownerDb.SaveChangesAsync();
            var job = new JobApplication { JobTitle = "Backend Developer", CompanyId = company.Id, OwnerUserId = "user-1" };
            ownerDb.JobApplications.Add(job);
            await ownerDb.SaveChangesAsync();
            var message = new Correspondence
            {
                JobApplicationId = job.Id,
                From = "Company",
                Subject = "Interview",
                Content = "Safe saved copy",
                ExternalLabelsJson = "not-json",
                AttachmentMetadataJson = "also-not-json"
            };
            ownerDb.Correspondences.Add(message);
            await ownerDb.SaveChangesAsync();
            messageId = message.Id;

            var ownerResult = await new CorrespondenceController(ownerDb).GetMessage(messageId, CancellationToken.None);
            var ok = Assert.IsType<OkObjectResult>(ownerResult.Result);
            var detail = Assert.IsType<EmailMessageDetailDto>(ok.Value);
            Assert.Equal("Safe saved copy", detail.BodyText);
            Assert.Empty(detail.Labels);
            Assert.Empty(detail.Attachments);

            var inboxResult = await new CorrespondenceController(ownerDb).GetInbox(null, null, null, CancellationToken.None);
            var inbox = Assert.IsType<OkObjectResult>(inboxResult.Result);
            var item = Assert.Single(Assert.IsType<List<CorrespondenceController.CorrespondenceInboxItemDto>>(inbox.Value));
            Assert.Equal(0, item.LabelCount);
            Assert.Equal(0, item.AttachmentCount);
        }

        var other = new Mock<ICurrentUserService>();
        other.SetupGet(service => service.UserId).Returns("user-2");
        await using var otherDb = new JobTrackerContext(options, other.Object);
        var otherResult = await new CorrespondenceController(otherDb).GetMessage(messageId, CancellationToken.None);
        Assert.IsType<NotFoundResult>(otherResult.Result);
    }
}