Implementation Guide: Surface patients with declining phq-9 or gad-7 scores for immediate clinician review

# FortiGate initial setup via CLI (connect via console cable at 9600 baud)
config system interface
  edit port1
    set mode static
    set ip 192.168.1.1/24
    set allowaccess ping https ssh
  next
end

# Create VLANs
config system interface
  edit vlan10-clinical
    set vdom root
    set type vlan
    set vlanid 10
    set interface port2
    set ip 10.10.10.1/24
    set allowaccess ping https
  next
  edit vlan20-patient
    set vdom root
    set type vlan
    set vlanid 20
    set interface port2
    set ip 10.10.20.1/24
    set allowaccess ping
  next
  edit vlan30-mgmt
    set vdom root
    set type vlan
    set vlanid 30
    set interface port2
    set ip 10.10.30.1/24
    set allowaccess ping https ssh
  next
end

# Enable logging for HIPAA audit trail
config log fortianalyzer setting
  set status enable
  set server <FortiAnalyzer-IP-or-Cloud>
  set enc-algorithm high
  set ssl-min-proto-ver tls1-2
end

# Configure SSL VPN for remote clinicians
config vpn ssl settings
  set servercert <cert-name>
  set tunnel-ip-pools SSLVPN_TUNNEL_ADDR
  set port 10443
  set source-interface port1
  set source-address all
  set default-portal full-access
end

# Enable MFA for VPN (integrate with FortiToken or Azure MFA)
config user fortitoken
  edit FTK-<serial>
  next
end

# Accept Microsoft BAA (must be done by Global Admin)
# Navigate to: Microsoft 365 Admin Center > Settings > Org Settings > Security & Privacy > HIPAA
# Accept the BAA - this is a prerequisite for HIPAA-compliant use of M365

# PowerShell: Connect to Microsoft 365 and enforce MFA via Conditional Access
Install-Module -Name Microsoft.Graph -Force
Connect-MgGraph -Scopes 'Policy.ReadWrite.ConditionalAccess'

# Create Conditional Access policy requiring MFA for all users
$params = @{
    displayName = 'Require MFA for All Users'
    state = 'enabled'
    conditions = @{
        users = @{ includeUsers = @('All') }
        applications = @{ includeApplications = @('All') }
    }
    grantControls = @{
        operator = 'OR'
        builtInControls = @('mfa')
    }
}
New-MgIdentityConditionalAccessPolicy -BodyParameter $params

# Configure Intune compliance policy for BitLocker
# Navigate to: Intune Admin Center > Devices > Compliance Policies > Create Policy
# Require: BitLocker enabled, minimum OS version, password complexity, device encryption

# Configure DLP policy for PHI
# Navigate to: Microsoft Purview Compliance Center > Data Loss Prevention > Policies
# Create policy using 'U.S. Health Insurance Act (HIPAA)' template
# Apply to: Exchange Online, OneDrive, SharePoint, Teams

# Windows Autopilot deployment (preferred method)
# 1. Obtain hardware hash from new devices
Install-Script -Name Get-WindowsAutopilotInfo
Get-WindowsAutopilotInfo -OutputFile C:\autopilot.csv

# Example: Blueprint Health + TherapyNotes integration
# TherapyNotes does not offer a public API; use Blueprint's native integration
# 1. In Blueprint: Settings > Integrations > TherapyNotes > Connect
# 2. Enter TherapyNotes practice credentials (admin-level)
# 3. Map clinician accounts between systems
# 4. Configure auto-enrollment: new patients added to TherapyNotes
#    automatically appear in Blueprint for assessment scheduling

# Example: Greenspace Health + AdvancedMD API integration
# 1. Greenspace integration team provides endpoint specifications
# 2. In AdvancedMD: Admin > API Settings > Create Application
# 3. Generate OAuth2 credentials
# 4. Provide credentials to Greenspace implementation team
# 5. Greenspace configures: patient sync, scheduling sync, score writeback

# Example: Custom FHIR R4 integration (for Epic, Cerner, etc.)
# Greenspace supports FHIR R4 endpoints for larger health systems
# 1. Register Greenspace as an approved FHIR application in the EHR
# 2. Configure SMART on FHIR authorization
# 3. Map FHIR resources: Patient, Encounter, QuestionnaireResponse
# 4. Test with synthetic data before enabling production sync

# For EHRs without API: SFTP-based CSV integration
# 1. Configure scheduled export from EHR (daily patient roster + scores)
# 2. Set up SFTP endpoint (Greenspace provides credentials)
sftp -i /path/to/key greenspace_user@sftp.greenspacehealth.com
put /exports/daily_roster_$(date +%Y%m%d).csv /incoming/
# 3. Greenspace ingests CSV on configurable schedule

// Power Query M script for Blueprint Health API connection
// In Power BI Desktop: Get Data > Web > Advanced
let
    Source = Web.Contents(
        "https://api.blueprint-health.com/v1/assessments",
        [
            Headers = [
                #"Authorization" = "Bearer " & ApiKey,
                #"Content-Type" = "application/json"
            ],
            Query = [
                assessment_type = "PHQ-9,GAD-7",
                date_from = Date.ToText(Date.AddMonths(DateTime.LocalNow(), -6), "yyyy-MM-dd"),
                date_to = Date.ToText(DateTime.LocalNow(), "yyyy-MM-dd"),
                page_size = "1000"
            ]
        ]
    ),
    JsonResponse = Json.Document(Source),
    Assessments = Table.FromList(JsonResponse[data], Splitter.SplitByNothing()),
    Expanded = Table.ExpandRecordColumn(Assessments, "Column1", 
        {"patient_id", "clinician_id", "assessment_type", "score", 
         "severity_band", "administered_date", "previous_score", "score_change"})
in
    Expanded

// Score Decline Rate:
Score Decline Rate = 
    DIVIDE(
        COUNTROWS(FILTER(Assessments, Assessments[score_change] > 0)),
        COUNTROWS(Assessments),
        0
    )

// Average PHQ-9 Score by Clinician:
Avg PHQ9 by Clinician = 
    CALCULATE(
        AVERAGE(Assessments[score]),
        Assessments[assessment_type] = "PHQ-9"
    )

// Patients Needing Review (declining):
Patients Needing Review = 
    COUNTROWS(
        FILTER(
            Assessments,
            Assessments[score_change] >= 5 
            && Assessments[assessment_type] = "PHQ-9"
            && Assessments[administered_date] >= TODAY() - 30
        )
    )

# HTTP trigger payload schema for MBC platform webhook

{
  "type": "Request",
  "kind": "Http",
  "inputs": {
    "schema": {
      "type": "object",
      "properties": {
        "alert_type": { "type": "string" },
        "patient_id": { "type": "string" },
        "patient_name": { "type": "string" },
        "clinician_email": { "type": "string" },
        "assessment_type": { "type": "string" },
        "current_score": { "type": "integer" },
        "previous_score": { "type": "integer" },
        "score_change": { "type": "integer" },
        "severity_band": { "type": "string" },
        "timestamp": { "type": "string" }
      }
    }
  }
}

# Role-Based Access Control configuration
# Azure AD Security Groups:
#   SG-Clinicians: Access to MBC platform (own patients only), EHR, Teams alerts
#   SG-ClinicalSupervisors: Access to all patient data, escalation alerts, Power BI
#   SG-PracticeAdmin: Access to billing, scheduling, aggregate reports (no PHI scores)
#   SG-MSP-Admins: Access to infrastructure only (firewall, Intune, M365 admin)

# PowerShell: Create security groups
Connect-MgGraph -Scopes 'Group.ReadWrite.All'
New-MgGroup -DisplayName 'SG-Clinicians' -MailEnabled:$false -MailNickname 'sg-clinicians' -SecurityEnabled:$true
New-MgGroup -DisplayName 'SG-ClinicalSupervisors' -MailEnabled:$false -MailNickname 'sg-clinicalsupervisors' -SecurityEnabled:$true
New-MgGroup -DisplayName 'SG-PracticeAdmin' -MailEnabled:$false -MailNickname 'sg-practiceadmin' -SecurityEnabled:$true

# Enable Microsoft 365 Unified Audit Logging
# PowerShell:
Connect-ExchangeOnline
Set-AdminAuditLogConfig -UnifiedAuditLogIngestionEnabled $true

# Verify audit logging is enabled:
Get-AdminAuditLogConfig | Format-List UnifiedAuditLogIngestionEnabled

# Configure audit log retention (requires M365 E5 or compliance add-on for >90 days)
# For standard M365 Business Premium: default 180-day retention
# For 6-year HIPAA retention: export logs monthly to Azure Blob Storage

# Azure Blob Storage for long-term audit log retention
# PowerShell:
az storage account create --name practiceauditlogs --resource-group rg-healthcare --location eastus --sku Standard_GRS --encryption-services blob
az storage container create --name audit-logs --account-name practiceauditlogs
az storage account management-policy create --account-name practiceauditlogs --policy @lifecycle-policy.json

# lifecycle-policy.json - move to cool storage after 90 days, archive after 1 year
# {
#   'rules': [{
#     'name': 'audit-log-lifecycle',
#     'type': 'Lifecycle',
#     'definition': {
#       'filters': { 'blobTypes': ['blockBlob'] },
#       'actions': {
#         'baseBlob': {
#           'tierToCool': { 'daysAfterModificationGreaterThan': 90 },
#           'tierToArchive': { 'daysAfterModificationGreaterThan': 365 },
#           'delete': { 'daysAfterModificationGreaterThan': 2555 }
#         }
#       }
#     }
#   }]
}

# Document BAA inventory
# Create a BAA tracking spreadsheet with:
# Vendor | BAA Execution Date | Expiration | Signatory | Copy Location
# Microsoft | [date] | Perpetual | [name] | SharePoint/Compliance/BAAs/
# Blueprint Health | [date] | Per contract | [name] | SharePoint/Compliance/BAAs/
# [MSP Name] | [date] | Per MSA | [name] | SharePoint/Compliance/BAAs/

curl -H 'Authorization: Bearer <API_KEY>' \
  https://api.blueprint-health.com/v1/organization/health

curl -H 'Authorization: Bearer <API_KEY>' \
  https://api.blueprint-health.com/v1/integrations/status

# Azure Function (Python) triggered by MBC platform webhook or scheduled API
# poll

# PHQ-9/GAD-7 Score Decline Detector
# Implementation as an Azure Function (Python) triggered by MBC platform webhook
# or scheduled to poll the MBC platform API

import json
import logging
import os
from datetime import datetime, timedelta
from typing import List, Dict, Optional
import azure.functions as func
import requests

# Configuration - set via Azure Function App Settings
MBC_API_BASE = os.environ.get('MBC_API_BASE', 'https://api.blueprint-health.com/v1')
MBC_API_KEY = os.environ.get('MBC_API_KEY')
TEAMS_WEBHOOK_URL = os.environ.get('TEAMS_WEBHOOK_URL')
SMTP_SERVER = os.environ.get('SMTP_SERVER')
ESCALATION_EMAIL = os.environ.get('ESCALATION_EMAIL')

# Clinical thresholds (evidence-based defaults)
PHQ9_RCI_THRESHOLD = 5  # Reliable Change Index for PHQ-9
GAD7_RCI_THRESHOLD = 4  # Reliable Change Index for GAD-7
PHQ9_SEVERE_THRESHOLD = 20
GAD7_SEVERE_THRESHOLD = 15
CONSECUTIVE_INCREASE_COUNT = 2

# PHQ-9 Severity Bands
PHQ9_BANDS = [
    (0, 4, 'Minimal'),
    (5, 9, 'Mild'),
    (10, 14, 'Moderate'),
    (15, 19, 'Moderately Severe'),
    (20, 27, 'Severe')
]

# GAD-7 Severity Bands
GAD7_BANDS = [
    (0, 4, 'Minimal'),
    (5, 9, 'Mild'),
    (10, 14, 'Moderate'),
    (15, 21, 'Severe')
]

def get_severity_band(score: int, assessment_type: str) -> str:
    bands = PHQ9_BANDS if assessment_type == 'PHQ-9' else GAD7_BANDS
    for low, high, label in bands:
        if low <= score <= high:
            return label
    return 'Unknown'

def get_band_index(score: int, assessment_type: str) -> int:
    bands = PHQ9_BANDS if assessment_type == 'PHQ-9' else GAD7_BANDS
    for i, (low, high, _) in enumerate(bands):
        if low <= score <= high:
            return i
    return -1

def analyze_patient_scores(patient_id: str, scores: List[Dict]) -> List[Dict]:
    """Analyze a patient's score history and return any triggered alerts."""
    alerts = []
    
    if len(scores) < 2:
        return alerts  # Need at least 2 data points
    
    # Sort by date ascending
    scores.sort(key=lambda x: x['administered_date'])
    
    current = scores[-1]
    previous = scores[-2]
    assessment_type = current['assessment_type']
    
    current_score = current['score']
    previous_score = previous['score']
    score_change = current_score - previous_score
    
    rci_threshold = PHQ9_RCI_THRESHOLD if assessment_type == 'PHQ-9' else GAD7_RCI_THRESHOLD
    severe_threshold = PHQ9_SEVERE_THRESHOLD if assessment_type == 'PHQ-9' else GAD7_SEVERE_THRESHOLD
    
    # Rule 1: Absolute score increase exceeding RCI
    if score_change >= rci_threshold:
        alerts.append({
            'rule': 'ABSOLUTE_INCREASE',
            'priority': 'HIGH',
            'patient_id': patient_id,
            'assessment_type': assessment_type,
            'current_score': current_score,
            'previous_score': previous_score,
            'score_change': score_change,
            'message': f'{assessment_type} increased by {score_change} points '
                       f'(from {previous_score} to {current_score}), '
                       f'exceeding the Reliable Change Index of {rci_threshold}.',
            'administered_date': current['administered_date']
        })
    
    # Rule 2: Severity band transition (worsening)
    current_band_idx = get_band_index(current_score, assessment_type)
    previous_band_idx = get_band_index(previous_score, assessment_type)
    if current_band_idx > previous_band_idx:
        current_band = get_severity_band(current_score, assessment_type)
        previous_band = get_severity_band(previous_score, assessment_type)
        alerts.append({
            'rule': 'BAND_TRANSITION',
            'priority': 'HIGH',
            'patient_id': patient_id,
            'assessment_type': assessment_type,
            'current_score': current_score,
            'previous_score': previous_score,
            'score_change': score_change,
            'message': f'{assessment_type} severity worsened from '
                       f'{previous_band} ({previous_score}) to '
                       f'{current_band} ({current_score}).',
            'administered_date': current['administered_date']
        })
    
    # Rule 3: Consecutive increases
    if len(scores) >= CONSECUTIVE_INCREASE_COUNT + 1:
        recent = scores[-(CONSECUTIVE_INCREASE_COUNT + 1):]
        consecutive_increases = all(
            recent[i+1]['score'] > recent[i]['score']
            for i in range(len(recent) - 1)
        )
        if consecutive_increases:
            trend_scores = [s['score'] for s in recent]
            alerts.append({
                'rule': 'CONSECUTIVE_INCREASE',
                'priority': 'MEDIUM',
                'patient_id': patient_id,
                'assessment_type': assessment_type,
                'current_score': current_score,
                'previous_score': previous_score,
                'score_change': score_change,
                'message': f'{assessment_type} has increased for '
                           f'{CONSECUTIVE_INCREASE_COUNT} consecutive '
                           f'administrations: {" \u2192 ".join(map(str, trend_scores))}.',
                'administered_date': current['administered_date']
            })
    
    # Rule 4: Critical safety item (PHQ-9 Item 9 - suicidality)
    if assessment_type == 'PHQ-9' and current.get('item_scores'):
        item9_score = current['item_scores'].get('item_9', 0)
        if item9_score > 0:
            alerts.append({
                'rule': 'CRITICAL_SAFETY',
                'priority': 'CRITICAL',
                'patient_id': patient_id,
                'assessment_type': assessment_type,
                'current_score': current_score,
                'previous_score': previous_score,
                'score_change': score_change,
                'message': f'CRITICAL: Patient endorsed PHQ-9 Item 9 '
                           f'(suicidal ideation) with a score of {item9_score}. '
                           f'Immediate clinician review required.',
                'administered_date': current['administered_date']
            })
    
    # Rule 5: High severity threshold
    if current_score >= severe_threshold:
        alerts.append({
            'rule': 'SEVERE_SCORE',
            'priority': 'CRITICAL',
            'patient_id': patient_id,
            'assessment_type': assessment_type,
            'current_score': current_score,
            'previous_score': previous_score,
            'score_change': score_change,
            'message': f'{assessment_type} score of {current_score} is in the '
                       f'Severe range (\u2265{severe_threshold}). '
                       f'Immediate clinician review required.',
            'administered_date': current['administered_date']
        })
    
    return alerts

def send_teams_notification(alert: Dict, patient_info: Dict, clinician_info: Dict):
    """Send an adaptive card to Microsoft Teams."""
    priority_colors = {
        'CRITICAL': '#FF0000',
        'HIGH': '#FF8C00',
        'MEDIUM': '#FFD700'
    }
    card = {
        'type': 'message',
        'attachments': [{
            'contentType': 'application/vnd.microsoft.card.adaptive',
            'content': {
                '$schema': 'http://adaptivecards.io/schemas/adaptive-card.json',
                'type': 'AdaptiveCard',
                'version': '1.4',
                'body': [
                    {
                        'type': 'Container',
                        'style': 'attention' if alert['priority'] == 'CRITICAL' else 'warning',
                        'items': [
                            {
                                'type': 'TextBlock',
                                'text': f"\U0001f6a8 {alert['priority']} ALERT: {alert['assessment_type']} Score Decline",
                                'weight': 'Bolder',
                                'size': 'Medium',
                                'color': 'Attention' if alert['priority'] == 'CRITICAL' else 'Warning'
                            }
                        ]
                    },
                    {
                        'type': 'FactSet',
                        'facts': [
                            {'title': 'Patient', 'value': patient_info.get('name', 'N/A')},
                            {'title': 'Clinician', 'value': clinician_info.get('name', 'N/A')},
                            {'title': 'Assessment', 'value': alert['assessment_type']},
                            {'title': 'Current Score', 'value': str(alert['current_score'])},
                            {'title': 'Previous Score', 'value': str(alert['previous_score'])},
                            {'title': 'Change', 'value': f"+{alert['score_change']}" if alert['score_change'] > 0 else str(alert['score_change'])},
                            {'title': 'Rule Triggered', 'value': alert['rule']},
                            {'title': 'Date', 'value': alert['administered_date']}
                        ]
                    },
                    {
                        'type': 'TextBlock',
                        'text': alert['message'],
                        'wrap': True
                    }
                ],
                'actions': [
                    {
                        'type': 'Action.OpenUrl',
                        'title': 'View in MBC Platform',
                        'url': f"{MBC_API_BASE.replace('/v1', '')}/patients/{alert['patient_id']}"
                    },
                    {
                        'type': 'Action.OpenUrl',
                        'title': 'Acknowledge Alert',
                        'url': f"{MBC_API_BASE.replace('/v1', '')}/alerts/acknowledge"
                    }
                ]
            }
        }]
    }
    requests.post(TEAMS_WEBHOOK_URL, json=card, timeout=10)

def main(req: func.HttpRequest) -> func.HttpResponse:
    """Azure Function entry point - processes webhook from MBC platform."""
    logging.info('Score decline detector triggered')
    
    try:
        payload = req.get_json()
    except ValueError:
        return func.HttpResponse('Invalid JSON', status_code=400)
    
    patient_id = payload.get('patient_id')
    assessment_type = payload.get('assessment_type')
    
    # Fetch patient score history from MBC platform API
    headers = {'Authorization': f'Bearer {MBC_API_KEY}'}
    response = requests.get(
        f'{MBC_API_BASE}/patients/{patient_id}/assessments',
        params={'type': assessment_type, 'limit': 10},
        headers=headers,
        timeout=30
    )
    
    if response.status_code != 200:
        logging.error(f'Failed to fetch scores: {response.status_code}')
        return func.HttpResponse('API error', status_code=502)
    
    scores = response.json().get('data', [])
    alerts = analyze_patient_scores(patient_id, scores)
    
    if alerts:
        # Fetch patient and clinician info for notifications
        patient_resp = requests.get(
            f'{MBC_API_BASE}/patients/{patient_id}',
            headers=headers, timeout=10
        )
        patient_info = patient_resp.json() if patient_resp.ok else {}
        clinician_info = patient_info.get('assigned_clinician', {})
        
        for alert in alerts:
            logging.info(f"Alert triggered: {alert['rule']} for patient {patient_id}")
            send_teams_notification(alert, patient_info, clinician_info)
    
    return func.HttpResponse(
        json.dumps({'alerts_generated': len(alerts), 'alerts': alerts}),
        mimetype='application/json',
        status_code=200
    )

# --- Azure Function configuration files ---

# function.json
# {
#   "scriptFile": "__init__.py",
#   "bindings": [
#     {
#       "authLevel": "function",
#       "type": "httpTrigger",
#       "direction": "in",
#       "name": "req",
#       "methods": ["post"]
#     },
#     {
#       "type": "http",
#       "direction": "out",
#       "name": "$return"
#     }
#   ]
# }

# requirements.txt
# azure-functions
# requests

# Azure Function App Settings (environment variables):
# MBC_API_BASE = https://api.blueprint-health.com/v1
# MBC_API_KEY = <from MBC platform>
# TEAMS_WEBHOOK_URL = <from Teams channel connector>
# ESCALATION_EMAIL = supervisor@practice.com

# Azure Function (timer trigger), runs daily at 7:00 AM

# Assessment Completion Rate Monitor
# Implemented as a scheduled Azure Function (timer trigger) or Power Automate scheduled flow
# Runs daily at 7:00 AM before first appointments

import json
import logging
import os
from datetime import datetime, timedelta
from typing import List, Dict
import azure.functions as func
import requests

MBC_API_BASE = os.environ.get('MBC_API_BASE')
MBC_API_KEY = os.environ.get('MBC_API_KEY')
TEAMS_WEBHOOK_URL = os.environ.get('TEAMS_WEBHOOK_ADMIN_URL')  # Admin channel
COMPLETION_TARGET = 0.80  # 80% target
COMPLETION_MINIMUM = 0.60  # 60% minimum - alert if below this

def get_completion_stats(lookback_days: int = 7) -> Dict:
    """Fetch assessment completion statistics for the past N days."""
    headers = {'Authorization': f'Bearer {MBC_API_KEY}'}
    start_date = (datetime.now() - timedelta(days=lookback_days)).strftime('%Y-%m-%d')
    end_date = datetime.now().strftime('%Y-%m-%d')
    
    response = requests.get(
        f'{MBC_API_BASE}/assessments/stats',
        params={'date_from': start_date, 'date_to': end_date},
        headers=headers, timeout=30
    )
    return response.json() if response.ok else {}

def get_missing_assessments(date: str) -> List[Dict]:
    """Get list of patients who had appointments but didn't complete assessments."""
    headers = {'Authorization': f'Bearer {MBC_API_KEY}'}
    response = requests.get(
        f'{MBC_API_BASE}/assessments/missing',
        params={'date': date},
        headers=headers, timeout=30
    )
    return response.json().get('data', []) if response.ok else []

def send_completion_report(stats: Dict, missing: List[Dict]):
    """Send daily completion report to admin Teams channel."""
    total_sent = stats.get('total_sent', 0)
    total_completed = stats.get('total_completed', 0)
    rate = total_completed / total_sent if total_sent > 0 else 0
    
    status_emoji = '✅' if rate >= COMPLETION_TARGET else ('⚠️' if rate >= COMPLETION_MINIMUM else '🔴')
    
    card = {
        'type': 'message',
        'attachments': [{
            'contentType': 'application/vnd.microsoft.card.adaptive',
            'content': {
                'type': 'AdaptiveCard',
                'version': '1.4',
                'body': [
                    {'type': 'TextBlock', 'text': f'{status_emoji} Daily MBC Completion Report', 'weight': 'Bolder', 'size': 'Medium'},
                    {'type': 'FactSet', 'facts': [
                        {'title': 'Period', 'value': 'Last 7 days'},
                        {'title': 'Assessments Sent', 'value': str(total_sent)},
                        {'title': 'Assessments Completed', 'value': str(total_completed)},
                        {'title': 'Completion Rate', 'value': f'{rate:.0%}'},
                        {'title': 'Target', 'value': f'{COMPLETION_TARGET:.0%}'},
                        {'title': 'Missed Yesterday', 'value': str(len(missing))}
                    ]},
                    {'type': 'TextBlock', 'text': 'Patients who missed assessments yesterday:', 'weight': 'Bolder', 'isVisible': len(missing) > 0},
                ] + [
                    {'type': 'TextBlock', 'text': f"• {m.get('patient_name', 'Unknown')} (Clinician: {m.get('clinician_name', 'Unknown')})"}
                    for m in missing[:10]  # Show top 10
                ]
            }
        }]
    }
    requests.post(TEAMS_WEBHOOK_URL, json=card, timeout=10)

def main(timer: func.TimerRequest) -> None:
    """Timer trigger - runs daily at 7:00 AM."""
    logging.info('Assessment completion monitor running')
    
    stats = get_completion_stats(lookback_days=7)
    yesterday = (datetime.now() - timedelta(days=1)).strftime('%Y-%m-%d')
    missing = get_missing_assessments(yesterday)
    
    send_completion_report(stats, missing)
    logging.info(f'Completion report sent. Rate: {stats.get("total_completed", 0)}/{stats.get("total_sent", 0)}')

# function.json for timer trigger:
# {
#   "scriptFile": "__init__.py",
#   "bindings": [
#     {
#       "name": "timer",
#       "type": "timerTrigger",
#       "direction": "in",
#       "schedule": "0 0 7 * * *"
#     }
#   ]
# }

# post-processing integration script

# MBC Alert-to-EHR Documentation Bridge
# Runs as a post-processing step after the Score Decline Detector generates an alert
# Writes a structured clinical note to the EHR via API or generates a document for manual import

import json
import os
from datetime import datetime
from typing import Dict
import requests

EHR_API_BASE = os.environ.get('EHR_API_BASE')  # e.g., TherapyNotes, SimplePractice API
EHR_API_KEY = os.environ.get('EHR_API_KEY')

def generate_clinical_note(alert: Dict, patient_info: Dict) -> str:
    """Generate a structured clinical note for EHR documentation."""
    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M')
    
    note = f"""MEASUREMENT-BASED CARE ALERT NOTIFICATION
========================================
Date/Time Generated: {timestamp}
Assessment Type: {alert['assessment_type']}
Alert Rule: {alert['rule']}
Alert Priority: {alert['priority']}

SCORE SUMMARY:
- Current Score: {alert['current_score']} ({get_severity_description(alert['current_score'], alert['assessment_type'])})
- Previous Score: {alert['previous_score']} ({get_severity_description(alert['previous_score'], alert['assessment_type'])})
- Score Change: {'+' if alert['score_change'] > 0 else ''}{alert['score_change']} points
- Assessment Date: {alert['administered_date']}

ALERT DETAILS:
{alert['message']}

{'⚠️ CRITICAL SAFETY ALERT: PHQ-9 Item 9 (suicidal ideation) was endorsed. Follow practice safety protocol immediately.' if alert['rule'] == 'CRITICAL_SAFETY' else ''}

CLINICIAN RESPONSE (to be completed by treating clinician):
- [ ] Alert reviewed on: ___/___/______
- [ ] Clinical action taken: _________________________________
- [ ] Treatment plan modified: Yes / No
- [ ] Patient contacted: Yes / No / Not indicated
- [ ] Safety assessment completed (if applicable): Yes / No / N/A
- [ ] Supervision consulted (if applicable): Yes / No / N/A
- Clinician signature: ______________________ Date: ___/___/______

Note: This alert was generated automatically by the Measurement-Based Care
monitoring system. The alert does not replace clinical judgment. Clinicians
should review the full clinical context before determining appropriate action.
"""
    return note

def get_severity_description(score: int, assessment_type: str) -> str:
    """Return severity band description for a score."""
    if assessment_type == 'PHQ-9':
        if score <= 4: return 'Minimal depression'
        elif score <= 9: return 'Mild depression'
        elif score <= 14: return 'Moderate depression'
        elif score <= 19: return 'Moderately severe depression'
        else: return 'Severe depression'
    elif assessment_type == 'GAD-7':
        if score <= 4: return 'Minimal anxiety'
        elif score <= 9: return 'Mild anxiety'
        elif score <= 14: return 'Moderate anxiety'
        else: return 'Severe anxiety'
    return 'Unknown'

def write_to_ehr(patient_id: str, note_text: str) -> bool:
    """Write the clinical note to the patient's EHR record."""
    headers = {
        'Authorization': f'Bearer {EHR_API_KEY}',
        'Content-Type': 'application/json'
    }
    
    # Generic EHR API note creation (adapt endpoint per EHR vendor)
    payload = {
        'patient_id': patient_id,
        'note_type': 'MBC_ALERT',
        'note_text': note_text,
        'created_date': datetime.now().isoformat(),
        'status': 'pending_review',
        'category': 'outcome_measure'
    }
    
    try:
        response = requests.post(
            f'{EHR_API_BASE}/patients/{patient_id}/notes',
            json=payload, headers=headers, timeout=30
        )
        return response.status_code in (200, 201)
    except requests.RequestException as e:
        # Fallback: generate PDF and send via secure email
        # or save to SharePoint for manual upload
        logging.error(f'EHR API write failed: {e}')
        return False

def process_alert_for_ehr(alert: Dict, patient_info: Dict) -> Dict:
    """Main entry point: generate note and write to EHR."""
    note_text = generate_clinical_note(alert, patient_info)
    success = write_to_ehr(alert['patient_id'], note_text)
    
    return {
        'patient_id': alert['patient_id'],
        'note_generated': True,
        'ehr_write_success': success,
        'fallback_required': not success,
        'timestamp': datetime.now().isoformat()
    }

# For EHRs without API support (e.g., some TherapyNotes configurations):
# 1. Generate the note as a PDF
# 2. Save to a monitored SharePoint folder
# 3. Admin staff manually uploads to patient chart
# 4. Track pending uploads in a Power Automate flow with reminders

import os
from openai import AzureOpenAI

client = AzureOpenAI(
    api_key=os.environ.get('AZURE_OPENAI_API_KEY'),
    api_version='2024-02-15-preview',
    azure_endpoint=os.environ.get('AZURE_OPENAI_ENDPOINT')
)

def generate_trend_report(aggregate_data: dict) -> str:
    """Generate a narrative trend report from aggregate practice data."""
    user_prompt = USER_PROMPT_TEMPLATE.format(**aggregate_data)
    
    response = client.chat.completions.create(
        model='gpt-4',  # Deployment name in Azure OpenAI
        messages=[
            {'role': 'system', 'content': SYSTEM_PROMPT},
            {'role': 'user', 'content': user_prompt}
        ],
        temperature=0.3,  # Low temperature for factual reporting
        max_tokens=2000
    )
    
    return response.choices[0].message.content

# Schedule this to run weekly (Sunday evening) via Azure Function timer trigger
# Send the generated report to the clinical director via email or Teams

# CPT 96127 Billing Documentation Generator
# CPT 96127: Brief emotional/behavioral assessment (e.g., depression inventory,
# attention-deficit/hyperactivity disorder scale), with scoring and documentation,
# per standardized instrument
#
# Reimbursement: ~$5-$12 per administration (varies by payer)
# Can be billed up to 4 units per encounter (4 different instruments)
# Must be billed with an E/M code for the encounter

from datetime import datetime
from typing import Dict, Optional

def generate_96127_documentation(
    patient_id: str,
    encounter_date: str,
    assessment_type: str,  # 'PHQ-9' or 'GAD-7'
    score: int,
    clinician_name: str,
    clinician_credentials: str,
    administration_method: str = 'patient_self_report',  # or 'clinician_administered'
    time_minutes: int = 3,
    item_scores: Optional[Dict] = None
) -> Dict:
    """Generate CPT 96127 billing documentation."""
    
    # Determine severity interpretation
    if assessment_type == 'PHQ-9':
        instrument_name = 'Patient Health Questionnaire-9 (PHQ-9)'
        condition = 'depression'
        if score <= 4:
            severity = 'Minimal depression'
            clinical_action = 'Continue current treatment plan. Monitor at next visit.'
        elif score <= 9:
            severity = 'Mild depression'
            clinical_action = 'Watchful waiting. Repeat PHQ-9 at follow-up. Consider treatment if symptoms persist.'
        elif score <= 14:
            severity = 'Moderate depression'
            clinical_action = 'Treatment plan indicated. Consider psychotherapy and/or pharmacotherapy.'
        elif score <= 19:
            severity = 'Moderately severe depression'
            clinical_action = 'Active treatment with psychotherapy and/or pharmacotherapy recommended.'
        else:
            severity = 'Severe depression'
            clinical_action = 'Immediate treatment initiation. Consider combination therapy. Assess safety.'
    elif assessment_type == 'GAD-7':
        instrument_name = 'Generalized Anxiety Disorder-7 (GAD-7)'
        condition = 'anxiety'
        if score <= 4:
            severity = 'Minimal anxiety'
            clinical_action = 'Continue current treatment plan. Monitor at next visit.'
        elif score <= 9:
            severity = 'Mild anxiety'
            clinical_action = 'Watchful waiting. Repeat GAD-7 at follow-up.'
        elif score <= 14:
            severity = 'Moderate anxiety'
            clinical_action = 'Consider psychotherapy and/or pharmacotherapy.'
        else:
            severity = 'Severe anxiety'
            clinical_action = 'Active treatment recommended. Consider combination therapy.'
    else:
        raise ValueError(f'Unsupported assessment type: {assessment_type}')
    
    administration_desc = (
        'Patient completed the assessment independently via electronic delivery '
        '(tablet/smartphone) prior to the clinical encounter.'
        if administration_method == 'patient_self_report'
        else 'Assessment was administered by the clinician during the clinical encounter.'
    )
    
    # Generate the billing note
    billing_note = (
        f'BRIEF EMOTIONAL/BEHAVIORAL ASSESSMENT (CPT 96127)\n'
        f'Date of Service: {encounter_date}\n'
        f'Standardized Instrument: {instrument_name}\n'
        f'Condition Screened: {condition.title()}\n\n'
        f'Administration: {administration_desc}\n'
        f'Scoring: Automated electronic scoring.\n'
        f'Total Score: {score} out of {27 if assessment_type == "PHQ-9" else 21}\n'
        f'Severity Classification: {severity}\n\n'
        f'Clinical Interpretation: Patient\'s {assessment_type} score of {score} '
        f'indicates {severity.lower()}. {clinical_action}\n\n'
        f'Time: Approximately {time_minutes} minutes for administration, scoring, '
        f'and interpretation.\n\n'
        f'Performed by: {clinician_name}, {clinician_credentials}'
    )
    
    # Generate billing record
    billing_record = {
        'cpt_code': '96127',
        'units': 1,  # 1 unit per standardized instrument
        'modifier': None,  # Add modifier 59 if billing multiple instruments same encounter
        'diagnosis_codes': [
            'F32.9' if assessment_type == 'PHQ-9' and score >= 10 else
            'F41.1' if assessment_type == 'GAD-7' and score >= 10 else
            'Z13.31' if assessment_type == 'PHQ-9' else 'Z13.39'
        ],
        'encounter_date': encounter_date,
        'patient_id': patient_id,
        'rendering_provider': clinician_name,
        'credentials': clinician_credentials,
        'documentation': billing_note,
        'assessment_type': assessment_type,
        'score': score,
        'severity': severity
    }
    
    return billing_record

# Usage example:
# record = generate_96127_documentation(
#     patient_id='PT-12345',
#     encounter_date='2025-01-15',
#     assessment_type='PHQ-9',
#     score=16,
#     clinician_name='Dr. Jane Smith',
#     clinician_credentials='PhD, Licensed Psychologist',
#     administration_method='patient_self_report',
#     time_minutes=3
# )
# 
# Revenue impact estimate:
# - 10 clinicians x 8 patients/day x 5 days/week x 48 weeks = 19,200 encounters/year
# - 80% completion rate = 15,360 billable 96127 units
# - At $8 average reimbursement = $122,880/year additional revenue
# - Even at 50% completion: $76,800/year