@erosolaraijs/cure 1.0.0 → 1.0.2

package/src/patient/patientPortal.ts

@@ -0,0 +1,1039 @@
+/**
+ * Patient-Facing Portal Interfaces
+ *
+ * Provides patient engagement features:
+ * - Treatment plan viewing
+ * - Side effect tracking
+ * - Medication adherence monitoring
+ * - Quality of life assessments
+ * - Secure messaging with care team
+ * - Educational content delivery
+ * - Appointment management
+ *
+ * All interfaces designed for health literacy and accessibility.
+ */
+
+import { EventEmitter } from 'events';
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PATIENT PORTAL TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export interface PatientAccount {
+  id: string;
+  mrn: string;
+  email: string;
+  phone?: string;
+  preferredLanguage: string;
+  preferredContactMethod: 'email' | 'sms' | 'phone' | 'portal';
+  accessLevel: 'full' | 'limited';
+  proxyAccess?: {
+    proxyId: string;
+    proxyName: string;
+    relationship: string;
+    permissions: ('view' | 'message' | 'schedule')[];
+  }[];
+  createdAt: Date;
+  lastLoginAt?: Date;
+  notificationPreferences: {
+    appointments: boolean;
+    labResults: boolean;
+    messages: boolean;
+    medications: boolean;
+    educational: boolean;
+  };
+}
+
+export interface PatientTreatmentSummary {
+  patientId: string;
+  diagnosis: {
+    condition: string;
+    diagnosisDate: Date;
+    stage?: string;
+    simpleExplanation: string;
+  };
+  currentTreatment: {
+    regimen: string;
+    medications: {
+      name: string;
+      purpose: string;
+      dose: string;
+      frequency: string;
+      instructions: string;
+      sideEffectsToWatch: string[];
+    }[];
+    startDate: Date;
+    cycleInfo?: {
+      currentCycle: number;
+      totalPlannedCycles?: number;
+      nextCycleDate?: Date;
+    };
+    whatToExpect: string[];
+    whenToCallDoctor: string[];
+  };
+  upcomingAppointments: {
+    date: Date;
+    type: string;
+    provider: string;
+    location: string;
+    preparation?: string;
+  }[];
+  careTeam: {
+    role: string;
+    name: string;
+    phone?: string;
+    messageable: boolean;
+  }[];
+  goals: {
+    goal: string;
+    progress?: number;
+    lastUpdated?: Date;
+  }[];
+}
+
+export interface SymptomReport {
+  id: string;
+  patientId: string;
+  reportedAt: Date;
+  symptoms: {
+    symptom: string;
+    severity: 1 | 2 | 3 | 4 | 5; // 1=Mild, 5=Severe
+    duration?: string;
+    interference: 'none' | 'little' | 'somewhat' | 'quite-a-bit' | 'very-much';
+    notes?: string;
+  }[];
+  overallFeeling: 1 | 2 | 3 | 4 | 5;
+  concernsForDoctor?: string;
+  requiresFollowUp: boolean;
+  followUpReason?: string;
+}
+
+export interface MedicationAdherenceLog {
+  patientId: string;
+  medication: string;
+  logs: {
+    scheduledTime: Date;
+    takenTime?: Date;
+    taken: boolean;
+    skippedReason?: string;
+    sideEffects?: string[];
+    notes?: string;
+  }[];
+  adherenceRate: number; // 0-100%
+  missedDoses: number;
+  streakDays: number;
+}
+
+export interface QualityOfLifeAssessment {
+  id: string;
+  patientId: string;
+  assessmentType: 'FACT-G' | 'EORTC-QLQ-C30' | 'PRO-CTCAE' | 'custom';
+  completedAt: Date;
+  responses: {
+    question: string;
+    category: 'physical' | 'emotional' | 'social' | 'functional' | 'symptoms';
+    response: number | string;
+    score?: number;
+  }[];
+  summaryScores: {
+    domain: string;
+    score: number;
+    maxScore: number;
+    interpretation: string;
+    changeFromLast?: number;
+  }[];
+  alerts: {
+    domain: string;
+    concern: string;
+    severity: 'low' | 'moderate' | 'high';
+    recommendation: string;
+  }[];
+}
+
+export interface PatientMessage {
+  id: string;
+  threadId: string;
+  patientId: string;
+  direction: 'inbound' | 'outbound';
+  sender: {
+    type: 'patient' | 'provider' | 'nurse' | 'system';
+    name: string;
+    id?: string;
+  };
+  recipient?: {
+    type: 'patient' | 'provider' | 'nurse' | 'care-team';
+    name: string;
+    id?: string;
+  };
+  subject?: string;
+  body: string;
+  attachments?: {
+    name: string;
+    type: string;
+    url: string;
+  }[];
+  sentAt: Date;
+  readAt?: Date;
+  priority: 'routine' | 'urgent';
+  category: 'question' | 'symptoms' | 'medication' | 'appointment' | 'billing' | 'other';
+  requiresResponse: boolean;
+  responseDeadline?: Date;
+  status: 'unread' | 'read' | 'responded' | 'closed';
+}
+
+export interface EducationalContent {
+  id: string;
+  title: string;
+  description: string;
+  contentType: 'article' | 'video' | 'infographic' | 'checklist' | 'faq';
+  targetAudience: string[];
+  cancerTypes?: string[];
+  treatmentTypes?: string[];
+  topics: string[];
+  readingLevel: 'basic' | 'intermediate' | 'advanced';
+  language: string;
+  content: string; // HTML or markdown
+  videoUrl?: string;
+  duration?: number; // minutes for video
+  author?: string;
+  reviewedBy?: string;
+  lastUpdated: Date;
+  relatedContent?: string[];
+}
+
+export interface AppointmentRequest {
+  id: string;
+  patientId: string;
+  requestType: 'new' | 'reschedule' | 'cancel';
+  appointmentType: string;
+  preferredDates: Date[];
+  preferredTimes: ('morning' | 'afternoon' | 'evening')[];
+  reason: string;
+  urgency: 'routine' | 'soon' | 'urgent';
+  notes?: string;
+  status: 'pending' | 'scheduled' | 'declined';
+  scheduledAppointment?: {
+    date: Date;
+    provider: string;
+    location: string;
+  };
+  submittedAt: Date;
+  processedAt?: Date;
+  processedBy?: string;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PATIENT PORTAL SERVICE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export class PatientPortalService extends EventEmitter {
+  private accounts: Map<string, PatientAccount> = new Map();
+  private treatmentSummaries: Map<string, PatientTreatmentSummary> = new Map();
+  private symptomReports: Map<string, SymptomReport[]> = new Map();
+  private adherenceLogs: Map<string, MedicationAdherenceLog[]> = new Map();
+  private qolAssessments: Map<string, QualityOfLifeAssessment[]> = new Map();
+  private messages: Map<string, PatientMessage[]> = new Map();
+  private educationalContent: Map<string, EducationalContent> = new Map();
+  private appointmentRequests: Map<string, AppointmentRequest[]> = new Map();
+
+  constructor() {
+    super();
+    this.initializeEducationalContent();
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // ACCOUNT MANAGEMENT
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Create a patient portal account
+   */
+  async createAccount(accountData: Omit<PatientAccount, 'id' | 'createdAt'>): Promise<PatientAccount> {
+    const id = `PAT-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    const account: PatientAccount = {
+      ...accountData,
+      id,
+      createdAt: new Date()
+    };
+
+    this.accounts.set(id, account);
+    this.emit('account-created', { accountId: id, mrn: account.mrn });
+
+    return account;
+  }
+
+  /**
+   * Get patient account
+   */
+  getAccount(patientId: string): PatientAccount | undefined {
+    return this.accounts.get(patientId);
+  }
+
+  /**
+   * Record patient login
+   */
+  recordLogin(patientId: string): void {
+    const account = this.accounts.get(patientId);
+    if (account) {
+      account.lastLoginAt = new Date();
+      this.emit('patient-login', { patientId });
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // TREATMENT SUMMARY
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Set patient treatment summary
+   */
+  setTreatmentSummary(summary: PatientTreatmentSummary): void {
+    this.treatmentSummaries.set(summary.patientId, summary);
+    this.emit('treatment-summary-updated', { patientId: summary.patientId });
+  }
+
+  /**
+   * Get patient-friendly treatment summary
+   */
+  getTreatmentSummary(patientId: string): PatientTreatmentSummary | undefined {
+    return this.treatmentSummaries.get(patientId);
+  }
+
+  /**
+   * Generate simple language summary
+   */
+  generateSimpleSummary(
+    diagnosis: string,
+    stage: string,
+    treatment: string
+  ): {
+    diagnosisExplanation: string;
+    treatmentExplanation: string;
+    whatItMeans: string[];
+  } {
+    // Convert medical terminology to patient-friendly language
+    const diagnosisExplanation = this.simplifyDiagnosis(diagnosis, stage);
+    const treatmentExplanation = this.simplifyTreatment(treatment);
+
+    const whatItMeans: string[] = [
+      'Your care team has created a treatment plan specifically for you',
+      'This plan is based on the specific characteristics of your cancer',
+      'Your doctors will monitor how well the treatment is working',
+      'You can ask questions at any time - your care team is here to help'
+    ];
+
+    return {
+      diagnosisExplanation,
+      treatmentExplanation,
+      whatItMeans
+    };
+  }
+
+  private simplifyDiagnosis(diagnosis: string, stage: string): string {
+    // Simplified explanations for common diagnoses
+    const simplifications: Record<string, string> = {
+      'NSCLC': 'non-small cell lung cancer, the most common type of lung cancer',
+      'SCLC': 'small cell lung cancer',
+      'Breast Cancer': 'breast cancer',
+      'Adenocarcinoma': 'a type of cancer that starts in gland cells',
+      'Squamous Cell Carcinoma': 'a type of cancer that starts in flat cells'
+    };
+
+    let explanation = `You have been diagnosed with ${simplifications[diagnosis] || diagnosis}. `;
+
+    // Stage explanation
+    if (stage) {
+      const stageNum = stage.replace(/[^IViv0-4]/g, '').toUpperCase();
+      if (stageNum.includes('I') && !stageNum.includes('V')) {
+        explanation += 'This is an early stage, which often has more treatment options.';
+      } else if (stageNum.includes('II')) {
+        explanation += 'This stage means the cancer has grown but is still considered treatable.';
+      } else if (stageNum.includes('III')) {
+        explanation += 'This is a more advanced stage, but many effective treatments are available.';
+      } else if (stageNum.includes('IV')) {
+        explanation += 'This stage means the cancer has spread, and treatment focuses on controlling the disease and maintaining quality of life.';
+      }
+    }
+
+    return explanation;
+  }
+
+  private simplifyTreatment(treatment: string): string {
+    const explanations: Record<string, string> = {
+      'immunotherapy': 'a treatment that helps your immune system fight the cancer',
+      'chemotherapy': 'medicine that kills fast-growing cells, including cancer cells',
+      'targeted therapy': 'medicine that targets specific features of cancer cells',
+      'radiation': 'high-energy beams that destroy cancer cells in a specific area',
+      'surgery': 'an operation to remove the cancer'
+    };
+
+    let explanation = treatment;
+    for (const [term, simple] of Object.entries(explanations)) {
+      if (treatment.toLowerCase().includes(term)) {
+        explanation = `Your treatment includes ${simple}.`;
+        break;
+      }
+    }
+
+    return explanation;
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // SYMPTOM TRACKING
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Submit a symptom report
+   */
+  async submitSymptomReport(
+    patientId: string,
+    symptoms: SymptomReport['symptoms'],
+    overallFeeling: SymptomReport['overallFeeling'],
+    concerns?: string
+  ): Promise<SymptomReport> {
+    const id = `SYM-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+
+    // Analyze symptoms for follow-up needs
+    const { requiresFollowUp, followUpReason } = this.analyzeSymptoms(symptoms, overallFeeling);
+
+    const report: SymptomReport = {
+      id,
+      patientId,
+      reportedAt: new Date(),
+      symptoms,
+      overallFeeling,
+      concernsForDoctor: concerns,
+      requiresFollowUp,
+      followUpReason
+    };
+
+    const patientReports = this.symptomReports.get(patientId) || [];
+    patientReports.push(report);
+    this.symptomReports.set(patientId, patientReports);
+
+    this.emit('symptom-report-submitted', { patientId, reportId: id, requiresFollowUp });
+
+    // Alert care team if needed
+    if (requiresFollowUp) {
+      this.emit('symptom-alert', {
+        patientId,
+        reportId: id,
+        reason: followUpReason,
+        severity: this.determineSeverity(symptoms)
+      });
+    }
+
+    return report;
+  }
+
+  /**
+   * Get symptom history for patient
+   */
+  getSymptomHistory(patientId: string, days?: number): SymptomReport[] {
+    const reports = this.symptomReports.get(patientId) || [];
+    if (!days) return reports;
+
+    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+    return reports.filter(r => r.reportedAt >= cutoff);
+  }
+
+  /**
+   * Get symptom trends
+   */
+  getSymptomTrends(patientId: string): {
+    symptom: string;
+    trend: 'improving' | 'stable' | 'worsening';
+    averageSeverity: number;
+    occurrences: number;
+  }[] {
+    const reports = this.getSymptomHistory(patientId, 30);
+    const symptomData = new Map<string, number[]>();
+
+    for (const report of reports) {
+      for (const symptom of report.symptoms) {
+        const data = symptomData.get(symptom.symptom) || [];
+        data.push(symptom.severity);
+        symptomData.set(symptom.symptom, data);
+      }
+    }
+
+    const trends: ReturnType<typeof this.getSymptomTrends> = [];
+
+    for (const [symptom, severities] of symptomData) {
+      const avg = severities.reduce((a, b) => a + b, 0) / severities.length;
+
+      // Determine trend
+      let trend: 'improving' | 'stable' | 'worsening' = 'stable';
+      if (severities.length >= 3) {
+        const recent = severities.slice(-3);
+        const earlier = severities.slice(0, Math.max(1, severities.length - 3));
+        const recentAvg = recent.reduce((a, b) => a + b, 0) / recent.length;
+        const earlierAvg = earlier.reduce((a, b) => a + b, 0) / earlier.length;
+
+        if (recentAvg < earlierAvg - 0.5) trend = 'improving';
+        else if (recentAvg > earlierAvg + 0.5) trend = 'worsening';
+      }
+
+      trends.push({
+        symptom,
+        trend,
+        averageSeverity: Math.round(avg * 10) / 10,
+        occurrences: severities.length
+      });
+    }
+
+    return trends.sort((a, b) => b.averageSeverity - a.averageSeverity);
+  }
+
+  private analyzeSymptoms(
+    symptoms: SymptomReport['symptoms'],
+    overallFeeling: number
+  ): { requiresFollowUp: boolean; followUpReason?: string } {
+    // Check for concerning symptoms
+    const concerningSymptoms = [
+      'fever', 'chest pain', 'shortness of breath', 'severe pain',
+      'bleeding', 'confusion', 'fainting', 'seizure'
+    ];
+
+    const severeSymptomsCount = symptoms.filter(s => s.severity >= 4).length;
+    const concerningFound = symptoms.find(s =>
+      concerningSymptoms.some(cs => s.symptom.toLowerCase().includes(cs))
+    );
+
+    if (concerningFound && concerningFound.severity >= 3) {
+      return {
+        requiresFollowUp: true,
+        followUpReason: `Patient reported ${concerningFound.symptom} with severity ${concerningFound.severity}/5`
+      };
+    }
+
+    if (severeSymptomsCount >= 2) {
+      return {
+        requiresFollowUp: true,
+        followUpReason: `Multiple severe symptoms reported (${severeSymptomsCount})`
+      };
+    }
+
+    if (overallFeeling <= 2) {
+      return {
+        requiresFollowUp: true,
+        followUpReason: 'Patient overall feeling is very poor'
+      };
+    }
+
+    return { requiresFollowUp: false };
+  }
+
+  private determineSeverity(symptoms: SymptomReport['symptoms']): 'low' | 'moderate' | 'high' {
+    const maxSeverity = Math.max(...symptoms.map(s => s.severity));
+    if (maxSeverity >= 4) return 'high';
+    if (maxSeverity >= 3) return 'moderate';
+    return 'low';
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // MEDICATION ADHERENCE
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Log medication taken
+   */
+  logMedicationTaken(
+    patientId: string,
+    medication: string,
+    scheduledTime: Date,
+    taken: boolean,
+    takenTime?: Date,
+    skippedReason?: string,
+    sideEffects?: string[]
+  ): void {
+    const logs = this.adherenceLogs.get(patientId) || [];
+    let medLog = logs.find(l => l.medication === medication);
+
+    if (!medLog) {
+      medLog = {
+        patientId,
+        medication,
+        logs: [],
+        adherenceRate: 100,
+        missedDoses: 0,
+        streakDays: 0
+      };
+      logs.push(medLog);
+    }
+
+    medLog.logs.push({
+      scheduledTime,
+      takenTime,
+      taken,
+      skippedReason,
+      sideEffects
+    });
+
+    // Update adherence metrics
+    const totalDoses = medLog.logs.length;
+    const takenDoses = medLog.logs.filter(l => l.taken).length;
+    medLog.adherenceRate = Math.round((takenDoses / totalDoses) * 100);
+    medLog.missedDoses = totalDoses - takenDoses;
+
+    // Calculate streak
+    const sortedLogs = [...medLog.logs].sort((a, b) =>
+      b.scheduledTime.getTime() - a.scheduledTime.getTime()
+    );
+    let streak = 0;
+    for (const log of sortedLogs) {
+      if (log.taken) streak++;
+      else break;
+    }
+    medLog.streakDays = streak;
+
+    this.adherenceLogs.set(patientId, logs);
+    this.emit('medication-logged', { patientId, medication, taken });
+
+    // Alert for poor adherence
+    if (medLog.adherenceRate < 80) {
+      this.emit('adherence-concern', {
+        patientId,
+        medication,
+        adherenceRate: medLog.adherenceRate
+      });
+    }
+  }
+
+  /**
+   * Get adherence summary
+   */
+  getAdherenceSummary(patientId: string): {
+    medications: MedicationAdherenceLog[];
+    overallAdherence: number;
+    concerns: string[];
+    encouragement: string;
+  } {
+    const medications = this.adherenceLogs.get(patientId) || [];
+
+    if (medications.length === 0) {
+      return {
+        medications: [],
+        overallAdherence: 100,
+        concerns: [],
+        encouragement: 'Great start! Remember to log your medications each day.'
+      };
+    }
+
+    const overallAdherence = Math.round(
+      medications.reduce((sum, m) => sum + m.adherenceRate, 0) / medications.length
+    );
+
+    const concerns: string[] = [];
+    for (const med of medications) {
+      if (med.adherenceRate < 80) {
+        concerns.push(`${med.medication} adherence is ${med.adherenceRate}% - please talk to your care team if you're having trouble`);
+      }
+    }
+
+    let encouragement: string;
+    if (overallAdherence >= 95) {
+      encouragement = 'Excellent! You\'re doing a great job staying on track with your medications.';
+    } else if (overallAdherence >= 80) {
+      encouragement = 'Good work! Try to take your medications at the same time each day to build a routine.';
+    } else {
+      encouragement = 'Remember, taking your medications as prescribed gives them the best chance to work. We\'re here to help if you\'re having difficulties.';
+    }
+
+    return { medications, overallAdherence, concerns, encouragement };
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // QUALITY OF LIFE ASSESSMENTS
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Submit quality of life assessment
+   */
+  async submitQoLAssessment(
+    patientId: string,
+    assessmentType: QualityOfLifeAssessment['assessmentType'],
+    responses: QualityOfLifeAssessment['responses']
+  ): Promise<QualityOfLifeAssessment> {
+    const id = `QOL-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+
+    // Score the assessment
+    const summaryScores = this.scoreAssessment(assessmentType, responses, patientId);
+    const alerts = this.identifyQoLAlerts(summaryScores);
+
+    const assessment: QualityOfLifeAssessment = {
+      id,
+      patientId,
+      assessmentType,
+      completedAt: new Date(),
+      responses,
+      summaryScores,
+      alerts
+    };
+
+    const patientAssessments = this.qolAssessments.get(patientId) || [];
+    patientAssessments.push(assessment);
+    this.qolAssessments.set(patientId, patientAssessments);
+
+    this.emit('qol-assessment-completed', { patientId, assessmentId: id });
+
+    // Alert for concerning scores
+    if (alerts.some(a => a.severity === 'high')) {
+      this.emit('qol-alert', { patientId, assessmentId: id, alerts });
+    }
+
+    return assessment;
+  }
+
+  /**
+   * Get QoL assessment history
+   */
+  getQoLHistory(patientId: string): QualityOfLifeAssessment[] {
+    return this.qolAssessments.get(patientId) || [];
+  }
+
+  private scoreAssessment(
+    type: QualityOfLifeAssessment['assessmentType'],
+    responses: QualityOfLifeAssessment['responses'],
+    patientId: string
+  ): QualityOfLifeAssessment['summaryScores'] {
+    // Group responses by category
+    const categories = new Map<string, { scores: number[]; maxScore: number }>();
+
+    for (const response of responses) {
+      const cat = response.category;
+      const data = categories.get(cat) || { scores: [], maxScore: 0 };
+      data.scores.push(response.score || 0);
+      data.maxScore = Math.max(data.maxScore, 5); // Assuming 5-point scale
+      categories.set(cat, data);
+    }
+
+    // Get previous assessment for comparison
+    const history = this.qolAssessments.get(patientId) || [];
+    const previous = history.length > 0 ? history[history.length - 1] : null;
+
+    const summaryScores: QualityOfLifeAssessment['summaryScores'] = [];
+
+    for (const [domain, data] of categories) {
+      const score = Math.round(data.scores.reduce((a, b) => a + b, 0) / data.scores.length * 10) / 10;
+      const maxScore = data.maxScore;
+
+      // Get previous score for this domain
+      let changeFromLast: number | undefined;
+      if (previous) {
+        const prevDomain = previous.summaryScores.find(s => s.domain === domain);
+        if (prevDomain) {
+          changeFromLast = Math.round((score - prevDomain.score) * 10) / 10;
+        }
+      }
+
+      summaryScores.push({
+        domain,
+        score,
+        maxScore,
+        interpretation: this.interpretScore(score, maxScore),
+        changeFromLast
+      });
+    }
+
+    return summaryScores;
+  }
+
+  private interpretScore(score: number, maxScore: number): string {
+    const percentage = (score / maxScore) * 100;
+    if (percentage >= 80) return 'Good - minimal impact on quality of life';
+    if (percentage >= 60) return 'Moderate - some impact on daily activities';
+    if (percentage >= 40) return 'Below average - noticeable impact on quality of life';
+    return 'Concerning - significant impact, please discuss with care team';
+  }
+
+  private identifyQoLAlerts(scores: QualityOfLifeAssessment['summaryScores']): QualityOfLifeAssessment['alerts'] {
+    const alerts: QualityOfLifeAssessment['alerts'] = [];
+
+    for (const score of scores) {
+      const percentage = (score.score / score.maxScore) * 100;
+
+      if (percentage < 40) {
+        alerts.push({
+          domain: score.domain,
+          concern: `${score.domain} score is below 40%`,
+          severity: 'high',
+          recommendation: 'Discuss with your care team at your next appointment'
+        });
+      } else if (percentage < 60 && score.changeFromLast !== undefined && score.changeFromLast < -1) {
+        alerts.push({
+          domain: score.domain,
+          concern: `${score.domain} has declined since last assessment`,
+          severity: 'moderate',
+          recommendation: 'Monitor and report if continues to decline'
+        });
+      }
+    }
+
+    return alerts;
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // SECURE MESSAGING
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Send a message
+   */
+  async sendMessage(
+    patientId: string,
+    body: string,
+    category: PatientMessage['category'],
+    priority: PatientMessage['priority'] = 'routine',
+    subject?: string
+  ): Promise<PatientMessage> {
+    const id = `MSG-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    const threadId = `THR-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`;
+
+    const message: PatientMessage = {
+      id,
+      threadId,
+      patientId,
+      direction: 'inbound',
+      sender: {
+        type: 'patient',
+        name: 'Patient', // Would be fetched from account
+        id: patientId
+      },
+      recipient: {
+        type: 'care-team',
+        name: 'Care Team'
+      },
+      subject,
+      body,
+      sentAt: new Date(),
+      priority,
+      category,
+      requiresResponse: true,
+      responseDeadline: priority === 'urgent'
+        ? new Date(Date.now() + 4 * 60 * 60 * 1000) // 4 hours for urgent
+        : new Date(Date.now() + 48 * 60 * 60 * 1000), // 48 hours for routine
+      status: 'unread'
+    };
+
+    const patientMessages = this.messages.get(patientId) || [];
+    patientMessages.push(message);
+    this.messages.set(patientId, patientMessages);
+
+    this.emit('message-sent', { patientId, messageId: id, category, priority });
+
+    return message;
+  }
+
+  /**
+   * Get messages for patient
+   */
+  getMessages(patientId: string, unreadOnly: boolean = false): PatientMessage[] {
+    const messages = this.messages.get(patientId) || [];
+    if (unreadOnly) {
+      return messages.filter(m => m.status === 'unread');
+    }
+    return messages.sort((a, b) => b.sentAt.getTime() - a.sentAt.getTime());
+  }
+
+  /**
+   * Mark message as read
+   */
+  markMessageRead(patientId: string, messageId: string): void {
+    const messages = this.messages.get(patientId) || [];
+    const message = messages.find(m => m.id === messageId);
+    if (message) {
+      message.status = 'read';
+      message.readAt = new Date();
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // EDUCATIONAL CONTENT
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Get recommended educational content
+   */
+  getRecommendedContent(patientId: string): EducationalContent[] {
+    const summary = this.treatmentSummaries.get(patientId);
+    if (!summary) {
+      return Array.from(this.educationalContent.values()).slice(0, 5);
+    }
+
+    // Match content based on patient's diagnosis and treatment
+    const diagnosis = summary.diagnosis.condition.toLowerCase();
+    const treatment = summary.currentTreatment.regimen.toLowerCase();
+
+    const relevantContent = Array.from(this.educationalContent.values()).filter(content => {
+      const matchesCancer = content.cancerTypes?.some(ct =>
+        diagnosis.includes(ct.toLowerCase())
+      );
+      const matchesTreatment = content.treatmentTypes?.some(tt =>
+        treatment.includes(tt.toLowerCase())
+      );
+      return matchesCancer || matchesTreatment;
+    });
+
+    return relevantContent.slice(0, 10);
+  }
+
+  /**
+   * Search educational content
+   */
+  searchContent(query: string): EducationalContent[] {
+    const lowerQuery = query.toLowerCase();
+    return Array.from(this.educationalContent.values()).filter(content =>
+      content.title.toLowerCase().includes(lowerQuery) ||
+      content.description.toLowerCase().includes(lowerQuery) ||
+      content.topics.some(t => t.toLowerCase().includes(lowerQuery))
+    );
+  }
+
+  private initializeEducationalContent(): void {
+    const content: EducationalContent[] = [
+      {
+        id: 'edu-1',
+        title: 'Understanding Your Cancer Treatment',
+        description: 'An overview of how cancer treatments work and what to expect.',
+        contentType: 'article',
+        targetAudience: ['new-patients', 'caregivers'],
+        topics: ['treatment', 'basics', 'getting-started'],
+        readingLevel: 'basic',
+        language: 'en',
+        content: '# Understanding Your Cancer Treatment\n\nThis guide explains the different types of cancer treatment...',
+        lastUpdated: new Date()
+      },
+      {
+        id: 'edu-2',
+        title: 'Managing Side Effects',
+        description: 'Tips for managing common side effects from cancer treatment.',
+        contentType: 'article',
+        targetAudience: ['patients', 'caregivers'],
+        topics: ['side-effects', 'self-care', 'management'],
+        readingLevel: 'basic',
+        language: 'en',
+        content: '# Managing Side Effects\n\nMany cancer treatments can cause side effects...',
+        lastUpdated: new Date()
+      },
+      {
+        id: 'edu-3',
+        title: 'What is Immunotherapy?',
+        description: 'Learn how immunotherapy helps your immune system fight cancer.',
+        contentType: 'video',
+        targetAudience: ['patients'],
+        treatmentTypes: ['immunotherapy'],
+        topics: ['immunotherapy', 'treatment-types'],
+        readingLevel: 'basic',
+        language: 'en',
+        content: '',
+        videoUrl: 'https://example.com/immunotherapy-video',
+        duration: 5,
+        lastUpdated: new Date()
+      },
+      {
+        id: 'edu-4',
+        title: 'Nutrition During Treatment',
+        description: 'Healthy eating tips while receiving cancer treatment.',
+        contentType: 'article',
+        targetAudience: ['patients', 'caregivers'],
+        topics: ['nutrition', 'self-care', 'wellness'],
+        readingLevel: 'basic',
+        language: 'en',
+        content: '# Nutrition During Treatment\n\nGood nutrition is important during cancer treatment...',
+        lastUpdated: new Date()
+      }
+    ];
+
+    for (const c of content) {
+      this.educationalContent.set(c.id, c);
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // APPOINTMENTS
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Request an appointment
+   */
+  async requestAppointment(request: Omit<AppointmentRequest, 'id' | 'status' | 'submittedAt'>): Promise<string> {
+    const id = `APT-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+
+    const fullRequest: AppointmentRequest = {
+      ...request,
+      id,
+      status: 'pending',
+      submittedAt: new Date()
+    };
+
+    const patientRequests = this.appointmentRequests.get(request.patientId) || [];
+    patientRequests.push(fullRequest);
+    this.appointmentRequests.set(request.patientId, patientRequests);
+
+    this.emit('appointment-requested', {
+      patientId: request.patientId,
+      requestId: id,
+      type: request.appointmentType,
+      urgency: request.urgency
+    });
+
+    return id;
+  }
+
+  /**
+   * Get appointment requests for patient
+   */
+  getAppointmentRequests(patientId: string): AppointmentRequest[] {
+    return this.appointmentRequests.get(patientId) || [];
+  }
+
+  /**
+   * Get dashboard data for patient
+   */
+  getDashboard(patientId: string): {
+    summary: PatientTreatmentSummary | undefined;
+    recentSymptoms: SymptomReport[];
+    adherence: ReturnType<typeof this.getAdherenceSummary>;
+    unreadMessages: number;
+    upcomingAppointments: PatientTreatmentSummary['upcomingAppointments'];
+    recommendedContent: EducationalContent[];
+    alerts: string[];
+  } {
+    const summary = this.getTreatmentSummary(patientId);
+    const recentSymptoms = this.getSymptomHistory(patientId, 7);
+    const adherence = this.getAdherenceSummary(patientId);
+    const messages = this.getMessages(patientId, true);
+    const content = this.getRecommendedContent(patientId);
+
+    const alerts: string[] = [];
+
+    // Check for concerning symptoms
+    const latestSymptom = recentSymptoms[recentSymptoms.length - 1];
+    if (latestSymptom?.requiresFollowUp) {
+      alerts.push('Please contact your care team about your recent symptoms');
+    }
+
+    // Check adherence
+    if (adherence.overallAdherence < 80) {
+      alerts.push('Your medication adherence has been below target - remember to take medications as prescribed');
+    }
+
+    // Check unread messages
+    if (messages.length > 0) {
+      alerts.push(`You have ${messages.length} unread message(s) from your care team`);
+    }
+
+    return {
+      summary,
+      recentSymptoms: recentSymptoms.slice(-5),
+      adherence,
+      unreadMessages: messages.length,
+      upcomingAppointments: summary?.upcomingAppointments || [],
+      recommendedContent: content.slice(0, 3),
+      alerts
+    };
+  }
+}
+
+export default PatientPortalService;