async function findDuplicates(db, resourceType, threshold = 0.85) {
    const pipeline = [
        {
            $match: { resourceType: resourceType }
        },
        {
            $lookup: {
                from: 'resources',
                let: {
                    code: '$code.coding.code',
                    date: '$effectiveDateTime',
                    source: '$meta.source'
                },
                pipeline: [
                    {
                        $match: {
                            $expr: {
                                $and: [
                                    { $eq: ['$resourceType', resourceType] },
                                    { $ne: ['$meta.source', '$$source'] },
                                    { $in: ['$$code', '$code.coding.code'] }
                                ]
                            }
                        }
                    },
                    {
                        $addFields: {
                            dateDiff: {
                                $abs: {
                                    $subtract: [
                                        { $toDate: '$effectiveDateTime' },
                                        { $toDate: '$$date' }
                                    ]
                                }
                            }
                        }
                    },
                    {
                        $match: {
                            dateDiff: { $lt: 3600000 } // 1 hour in ms
                        }
                    }
                ],
                as: 'candidates'
            }
        },
        {
            $unwind: '$candidates'
        },
        {
            $project: {
                _id: 1,
                resourceType: 1,
                candidate: '$candidates',
                similarity: {
                    $add: [
                        0.4, // code match
                        { $multiply: [0.3,
                            { $subtract: [1,
                                { $divide: ['$candidates.dateDiff', 86400000] }
                            ]}
                        ]}
                    ]
                }
            }
        },
        {
            $match: {
                similarity: { $gte: threshold }
            }
        },
        {
            $sort: { similarity: -1 }
        }
    ];

    return await db.collection('resources').aggregate(pipeline).toArray();
}

function analyzeTrend(observations, windowDays = 30, clinicalThreshold = 2) {
    // Filter to time window
    const cutoff = Date.now() - (windowDays * 86400000);
    let recent = observations.filter(o =>
        new Date(o.effectiveDateTime).getTime() > cutoff
    );

    // Remove outliers
    const values = recent.map(o => o.valueQuantity.value);
    const mean = values.reduce((a,b) => a+b) / values.length;
    const stdDev = Math.sqrt(
        values.reduce((sq, v) => sq + Math.pow(v - mean, 2), 0) / values.length
    );

    recent = recent.filter(o =>
        Math.abs(o.valueQuantity.value - mean) <= 3 * stdDev
    );

    // Prepare data for regression
    const n = recent.length;
    const baseTime = new Date(recent[0].effectiveDateTime).getTime();
    const x = recent.map(o =>
        (new Date(o.effectiveDateTime).getTime() - baseTime) / 86400000
    );
    const y = recent.map(o => o.valueQuantity.value);

    // Calculate regression
    const xMean = x.reduce((a,b) => a+b) / n;
    const yMean = y.reduce((a,b) => a+b) / n;

    let sumXY = 0, sumX2 = 0;
    for (let i = 0; i < n; i++) {
        sumXY += (x[i] - xMean) * (y[i] - yMean);
        sumX2 += Math.pow(x[i] - xMean, 2);
    }

    const slope = sumXY / sumX2;
    const intercept = yMean - slope * xMean;

    // Calculate R²
    let SSR = 0, SST = 0;
    for (let i = 0; i < n; i++) {
        const predicted = intercept + slope * x[i];
        SSR += Math.pow(predicted - yMean, 2);
        SST += Math.pow(y[i] - yMean, 2);
    }
    const rSquared = SSR / SST;

    // Simplified p-value (t-distribution)
    let SSE = 0;
    for (let i = 0; i < n; i++) {
        SSE += Math.pow(y[i] - intercept - slope * x[i], 2);
    }
    const seBeta = Math.sqrt(SSE / ((n - 2) * sumX2));
    const tStat = slope / seBeta;
    const pValue = 2 * (1 - tCDF(Math.abs(tStat), n - 2));

    return {
        significant: pValue < 0.05 && Math.abs(slope) > clinicalThreshold && rSquared > 0.5,
        direction: slope > 0 ? 'increasing' : 'decreasing',
        rate: slope,
        confidence: rSquared,
        pValue: pValue
    };
}

async function checkMedicationInteractions(medicationStatements) {
    const active = medicationStatements.filter(m => m.status === 'active');

    // Extract RxNorm codes
    const rxnormCodes = active.map(m => {
        const coding = m.medicationCodeableConcept?.coding?.find(
            c => c.system === 'http://www.nlm.nih.gov/research/umls/rxnorm'
        );
        return coding?.code;
    }).filter(Boolean);

    const interactions = [];

    // Check all pairs
    for (let i = 0; i < rxnormCodes.length - 1; i++) {
        for (let j = i + 1; j < rxnormCodes.length; j++) {
            const response = await fetch(
                `https://rxnav.nlm.nih.gov/REST/interaction/interaction.json?` +
                `rxcui=${rxnormCodes[i]}&rxcui=${rxnormCodes[j]}`
            );

            const data = await response.json();

            if (data.interactionTypeGroup) {
                data.interactionTypeGroup.forEach(group => {
                    group.interactionType.forEach(type => {
                        type.interactionPair.forEach(pair => {
                            interactions.push({
                                medication1: pair.interactionConcept[0].minConceptItem.name,
                                medication2: pair.interactionConcept[1].minConceptItem.name,
                                severity: pair.severity,
                                description: pair.description
                            });
                        });
                    });
                });
            }
        }
    }

    return interactions.sort((a, b) =>
        severityRank(b.severity) - severityRank(a.severity)
    );
}

function severityRank(severity) {
    const ranks = { 'high': 3, 'moderate': 2, 'low': 1 };
    return ranks[severity?.toLowerCase()] || 0;
}

const GUIDELINES = [
    {
        name: 'Colonoscopy',
        appliesTo: p => p.age >= 45,
        procedureCodes: ['73761001'], // SNOMED
        intervalYears: 10
    },
    {
        name: 'Mammogram',
        appliesTo: p => p.sex === 'female' && p.age >= 40,
        procedureCodes: ['71651007'],
        intervalYears: 2
    },
    {
        name: 'Flu Vaccine',
        appliesTo: p => true,
        procedureCodes: ['86198006'],
        intervalYears: 1
    },
    {
        name: 'Lipid Panel',
        appliesTo: p => p.age >= 35,
        procedureCodes: ['24331-1'], // LOINC
        intervalYears: 5
    }
];

async function findCareGaps(db, patientId) {
    const patient = await db.collection('Patient').findOne({ id: patientId });
    const age = calculateAge(patient.birthDate);
    patient.age = age;
    patient.sex = patient.gender;

    const gaps = [];

    for (const guideline of GUIDELINES) {
        if (!guideline.appliesTo(patient)) continue;

        // Find last occurrence
        const lastProcedure = await db.collection('Procedure').findOne({
            'subject.reference': `Patient/${patientId}`,
            'code.coding.code': { $in: guideline.procedureCodes }
        }, {
            sort: { 'performedDateTime': -1 }
        });

        if (!lastProcedure) {
            gaps.push({
                guideline: guideline.name,
                status: 'never_performed',
                priority: 'high'
            });
        } else {
            const lastDate = new Date(lastProcedure.performedDateTime);
            const daysSince = (Date.now() - lastDate.getTime()) / 86400000;
            const intervalDays = guideline.intervalYears * 365;

            if (daysSince > intervalDays) {
                gaps.push({
                    guideline: guideline.name,
                    status: 'overdue',
                    lastDate: lastDate,
                    daysOverdue: Math.floor(daysSince - intervalDays),
                    priority: daysSince > intervalDays * 1.5 ? 'high' : 'medium'
                });
            }
        }
    }

    return gaps.sort((a, b) => {
        if (a.priority !== b.priority) {
            return a.priority === 'high' ? -1 : 1;
        }
        return (b.daysOverdue || 0) - (a.daysOverdue || 0);
    });
}

function calculateAge(birthDate) {
    const today = new Date();
    const birth = new Date(birthDate);
    let age = today.getFullYear() - birth.getFullYear();
    const m = today.getMonth() - birth.getMonth();
    if (m < 0 || (m === 0 && today.getDate() < birth.getDate())) {
        age--;
    }
    return age;
}

async function generatePatientSummary(bundle, summaryType = 'brief') {
    // Extract and normalize
    const conditions = bundle.entry
        .filter(e => e.resource.resourceType === 'Condition' &&
                     e.resource.clinicalStatus?.coding?.[0]?.code === 'active')
        .map(e => ({
            code: e.resource.code.coding[0].display,
            onset: e.resource.onsetDateTime
        }));

    const medications = bundle.entry
        .filter(e => e.resource.resourceType === 'MedicationStatement' &&
                     e.resource.status === 'active')
        .map(e => e.resource.medicationCodeableConcept.text);

    const recentVitals = bundle.entry
        .filter(e => {
            if (e.resource.resourceType !== 'Observation') return false;
            const date = new Date(e.resource.effectiveDateTime);
            return (Date.now() - date.getTime()) < 30 * 86400000;
        })
        .map(e => ({
            type: e.resource.code.coding[0].display,
            value: e.resource.valueQuantity.value,
            unit: e.resource.valueQuantity.unit,
            date: e.resource.effectiveDateTime
        }));

    // Build prompt
    const prompt = `
Generate a ${summaryType} clinical summary for this patient:

Active Conditions: ${conditions.map(c => c.code).join(', ') || 'None documented'}
Current Medications: ${medications.join(', ') || 'None'}
Recent Vitals (last 30 days): ${formatVitals(recentVitals)}

Guidelines:
- Use plain language suitable for patient understanding
- Highlight any concerning trends
- Do not fabricate information not present in the data
- Format as 2-3 paragraphs
- Include disclaimer about AI generation
`;

    // Call LLM API (example with OpenAI)
    const response = await fetch('https://api.openai.com/v1/chat/completions', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`
        },
        body: JSON.stringify({
            model: 'gpt-4',
            messages: [
                { role: 'system', content: 'You are a medical summarization assistant.' },
                { role: 'user', content: prompt }
            ],
            max_tokens: 500,
            temperature: 0.3
        })
    });

    const data = await response.json();
    const summary = data.choices[0].message.content;

    // Validate (check for hallucinations)
    if (containsFabricatedInfo(summary, bundle)) {
        throw new Error('Summary contains information not in source data');
    }

    return summary + '\n\n*This summary was generated by AI and should be reviewed by a healthcare professional.*';
}

function formatVitals(vitals) {
    return vitals.map(v => `${v.type}: ${v.value} ${v.unit}`).join('; ');
}

function containsFabricatedInfo(summary, bundle) {
    // Simple check: verify mentioned conditions/meds exist in bundle
    const allText = JSON.stringify(bundle).toLowerCase();
    const summaryLower = summary.toLowerCase();

    // Extract medical terms from summary (simplified)
    const medicalTerms = summaryLower.match(/\b[a-z]{5,}\b/g) || [];

    // Check if unusual terms appear in summary but not in bundle
    const suspicious = medicalTerms.filter(term =>
        !allText.includes(term) && isMedicalTerm(term)
    );

    return suspicious.length > 3; // Threshold for concern
}

function isMedicalTerm(word) {
    // Simplified check - in production, use medical ontology
    const commonMedical = ['diabetes', 'hypertension', 'asthma', 'copd',
                           'medication', 'blood', 'pressure', 'glucose'];
    return commonMedical.includes(word);
}