vigilcare-clinical/VigilCareClinicalAPI/Services/PatientService.cs

using System.Text.Json;
using Microsoft.EntityFrameworkCore;

public class PatientService : IPatientService
{
    private readonly AppDbContext _db;
    private readonly IExternalIdentifierService _identifiers;
    private readonly IAuditService _audit;

    public PatientService(
        AppDbContext db,
        IExternalIdentifierService identifiers,
        IAuditService audit)
    {
        _db = db;
        _identifiers = identifiers;
        _audit = audit;
    }

    public async Task<Patient> RegisterAsync(RegisterPatientRequest req)
    {
        var mrn = await GenerateMrnAsync();
        var patient = new Patient
        {
            Id = Guid.NewGuid(),
            Mrn = mrn,
            FirstName = req.FirstName,
            LastName = req.LastName,
            DateOfBirth = req.DateOfBirth,
            Gender = req.Gender,
            BloodType = req.BloodType,
            Allergies = req.Allergies,
            EmergencyContactName = req.EmergencyContactName,
            EmergencyContactPhone = req.EmergencyContactPhone,
            CreatedAt = DateTimeOffset.UtcNow
        };
        _db.Patients.Add(patient);
        await _db.SaveChangesAsync();

        await _audit.WriteAsync(
            AuditAction.PatientRegistered,
            "Patient",
            patient.Id,
            newValue: new { patient.Mrn, patient.FirstName, patient.LastName });

        return patient;
    }

    public async Task<PagedResult<Patient>> ListAsync(
        string? q, int page, int pageSize)
    {
        var query = _db.Patients.AsQueryable();

        if (!string.IsNullOrWhiteSpace(q))
        {
            query = query.Where(p =>
                p.Mrn == q ||
                EF.Functions.ILike(p.FirstName, $"%{q}%") ||
                EF.Functions.ILike(p.LastName, $"%{q}%"));
        }

        var total = await query.CountAsync();
        var patients = await query
            .OrderBy(p => p.LastName).ThenBy(p => p.FirstName)
            .Skip((page - 1) * pageSize)
            .Take(pageSize)
            .ToListAsync();

        return new PagedResult<Patient>(patients, page, pageSize, total);
    }

    public async Task<Patient> GetByIdAsync(Guid id)
    {
        var patient = await _db.Patients
            .Include(p => p.Encounters.Where(e => e.Status == EncounterStatus.Active))
            .FirstOrDefaultAsync(p => p.Id == id);

        if (patient is null)
            throw new NotFoundException("Patient not found.", "PATIENT_NOT_FOUND");

        return patient;
    }

    public async Task<Encounter> OpenEncounterAsync(Guid patientId, OpenEncounterRequest req)
    {
        var patient = await _db.Patients.FindAsync(patientId);
        if (patient is null)
            throw new NotFoundException("Patient not found.", "PATIENT_NOT_FOUND");

        var hasActiveOfType = await _db.Encounters.AnyAsync(e =>
            e.PatientId == patientId &&
            e.EncounterType == req.EncounterType &&
            e.Status == EncounterStatus.Active);

        if (hasActiveOfType)
            throw new ConflictException(
                "Patient already has an active encounter of this type.",
                "DUPLICATE_ACTIVE_ENCOUNTER");

        var encounter = new Encounter
        {
            Id = Guid.NewGuid(),
            PatientId = patientId,
            EncounterType = req.EncounterType,
            Status = EncounterStatus.Active,
            Department = req.Department,
            AttendingPhysician = req.AttendingPhysician,
            RoomBed = req.RoomBed,
            AdmissionReason = req.AdmissionReason,
            AdmittedAt = DateTimeOffset.UtcNow,
            CreatedAt = DateTimeOffset.UtcNow
        };
        _db.Encounters.Add(encounter);

        _db.OutboxEvents.Add(new OutboxEvent
        {
            Id = Guid.NewGuid(),
            Topic = "encounter.status.changed",
            Payload = JsonSerializer.Serialize(new
            {
                encounterId = encounter.Id,
                patientId = patient.Id,
                mrn = patient.Mrn,
                patientName = $"{patient.FirstName} {patient.LastName}",
                previousStatus = (string?)null,
                newStatus = encounter.Status.ToDbString(),
                department = encounter.Department.ToDbString(),
                attendingPhysician = encounter.AttendingPhysician,
                roomBed = encounter.RoomBed,
                admissionReason = encounter.AdmissionReason,
                admittedAt = encounter.AdmittedAt,
                changedAt = DateTimeOffset.UtcNow
            }),
            PartitionKey = encounter.Id.ToString(),
            CreatedAt = DateTimeOffset.UtcNow
        });

        await _db.SaveChangesAsync();
        return encounter;
    }

    public async Task<Patient> RegisterOrUpdateByIdentifierAsync(FhirPatientUpsertRequest req)
    {
        var existingId = await _identifiers.ResolveInternalIdAsync(
            ExternalResourceType.Patient, req.IdentifierSystem, req.IdentifierValue);

        if (existingId.HasValue)
        {
            var patient = await _db.Patients.FindAsync(existingId.Value)
                ?? throw new NotFoundException("Patient not found.", "PATIENT_NOT_FOUND");

            patient.FirstName = req.FirstName;
            patient.LastName = req.LastName;
            patient.DateOfBirth = req.DateOfBirth;
            patient.Gender = req.Gender;
            patient.BloodType = req.BloodType;
            patient.Allergies = req.Allergies;
            patient.EmergencyContactName = req.EmergencyContactName;
            patient.EmergencyContactPhone = req.EmergencyContactPhone;

            await _db.SaveChangesAsync();
            return patient;
        }

        // Use hospital identifier value as MRN when it fits the column constraint (max 20 chars).
        var mrn = req.IdentifierValue.Length <= 20
            ? req.IdentifierValue
            : await GenerateMrnAsync();

        var newPatient = new Patient
        {
            Id = Guid.NewGuid(),
            Mrn = mrn,
            FirstName = req.FirstName,
            LastName = req.LastName,
            DateOfBirth = req.DateOfBirth,
            Gender = req.Gender,
            BloodType = req.BloodType,
            Allergies = req.Allergies,
            EmergencyContactName = req.EmergencyContactName,
            EmergencyContactPhone = req.EmergencyContactPhone,
            CreatedAt = DateTimeOffset.UtcNow
        };

        _db.Patients.Add(newPatient);
        await _db.SaveChangesAsync();

        await _identifiers.LinkAsync(
            ExternalResourceType.Patient,
            newPatient.Id,
            req.IdentifierSystem,
            req.IdentifierValue);

        return newPatient;
    }

    private async Task<string> GenerateMrnAsync()
    {
        var count = await _db.Patients.CountAsync();
        return $"MRN-{(count + 1):D6}";
    }
}