import requests
from typing import List, Dict, Optional
from datetime import datetime

class AtonTrialsAPI:
    def __init__(self, base_url: str, auth_client):
        self.base_url = base_url
        self.auth_client = auth_client
        self._trials_cache = None
        self._cache_timestamp = None
        self._cache_duration = 300  # 5 minutes

    def get_all_trials(self, use_cache: bool = True) -> List[Dict]:
        """
        Retrieve all active clinical trials.

        Args:
            use_cache: Whether to use cached results if available

        Returns:
            List of trial dictionaries
        """
        # Check cache if requested
        if use_cache and self._is_cache_valid():
            return self._trials_cache

        token = self.auth_client.get_access_token()

        response = requests.get(
            f"{self.base_url}/referrals/trials",
            headers={
                "Authorization": f"Bearer {token}",
                "Content-Type": "application/json"
            }
        )
        response.raise_for_status()

        data = response.json()
        trials = data.get('trials', [])

        # Update cache
        self._trials_cache = trials
        self._cache_timestamp = datetime.now()

        return trials

    def get_trial_by_id(self, trial_id: str) -> Optional[Dict]:
        """
        Get a specific trial by its ID.

        Args:
            trial_id: The trial ID to search for

        Returns:
            Trial dictionary if found, None otherwise
        """
        trials = self.get_all_trials()

        for trial in trials:
            if trial.get('trialId') == trial_id or trial.get('altTrialId') == trial_id:
                return trial

        return None

    def get_trials_by_name_pattern(self, pattern: str) -> List[Dict]:
        """
        Search for trials by name pattern (case-insensitive).

        Args:
            pattern: Text pattern to search for in trial names

        Returns:
            List of matching trials
        """
        trials = self.get_all_trials()
        pattern_lower = pattern.lower()

        return [
            trial for trial in trials
            if pattern_lower in trial.get('name', '').lower()
        ]

    def validate_trial_exists(self, trial_id: str) -> bool:
        """
        Check if a trial ID exists in the active trials list.

        Args:
            trial_id: The trial ID to validate

        Returns:
            True if trial exists and is active, False otherwise
        """
        return self.get_trial_by_id(trial_id) is not None

    def get_trial_summary(self) -> Dict:
        """
        Get summary information about all active trials.

        Returns:
            Dictionary with trial count and summary statistics
        """
        trials = self.get_all_trials()

        # Group trials by version patterns
        version_counts = {}
        for trial in trials:
            version_id = trial.get('versionId', '')
            # Extract version suffix (e.g., 'v1', 'v2')
            if 'v' in version_id:
                version_suffix = version_id.split('v')[-1]
                version_counts[version_suffix] = version_counts.get(version_suffix, 0) + 1

        return {
            'total_trials': len(trials),
            'version_distribution': version_counts,
            'trial_names': [trial.get('name', 'Unnamed') for trial in trials],
            'last_updated': self._cache_timestamp.isoformat() if self._cache_timestamp else None
        }

    def _is_cache_valid(self) -> bool:
        """Check if the cached trials data is still valid."""
        if not self._trials_cache or not self._cache_timestamp:
            return False

        age = (datetime.now() - self._cache_timestamp).total_seconds()
        return age < self._cache_duration

# Usage examples
from aton_auth import AtonHealthAuth  # Your auth implementation

auth = AtonHealthAuth()
trials_api = AtonTrialsAPI("https://api.aton.health/api/v1", auth)

# Get all active trials
try:
    all_trials = trials_api.get_all_trials()
    print(f"Found {len(all_trials)} active trials:")

    for trial in all_trials:
        print(f"  • {trial['name']} (ID: {trial['trialId']})")

except requests.exceptions.RequestException as e:
    print(f"Error fetching trials: {e}")

# Validate a trial ID before submitting referral
trial_id = "Aton_ColonoscopyPrep_20250930"
if trials_api.validate_trial_exists(trial_id):
    print(f"Trial {trial_id} is active and accepting referrals")
else:
    print(f"Trial {trial_id} not found or not active")

# Search for specific trials
diabetes_trials = trials_api.get_trials_by_name_pattern("diabetes")
print(f"Found {len(diabetes_trials)} diabetes-related trials")

# Get summary statistics
summary = trials_api.get_trial_summary()
print(f"Trial Summary:")
print(f"Total Trials: {summary['total_trials']}")
print(f"Version Distribution: {summary['version_distribution']}")

import asyncio
from datetime import datetime

async def monitor_trial_changes(trials_api, callback, interval_seconds=300):
    """
    Monitor for changes in active trials.
    """
    last_trials = {}

    while True:
        try:
            current_trials = await trials_api.get_all_trials(use_cache=False)
            current_trial_dict = {t['trialId']: t for t in current_trials}

            if last_trials:
                # Check for new trials
                new_trials = [t for tid, t in current_trial_dict.items() 
                             if tid not in last_trials]

                # Check for removed trials
                removed_trial_ids = [tid for tid in last_trials 
                                   if tid not in current_trial_dict]

                # Check for version changes
                updated_trials = []
                for tid, trial in current_trial_dict.items():
                    if (tid in last_trials and 
                        last_trials[tid]['versionId'] != trial['versionId']):
                        updated_trials.append(trial)

                if new_trials or removed_trial_ids or updated_trials:
                    await callback({
                        'timestamp': datetime.utcnow(),
                        'new_trials': new_trials,
                        'removed_trial_ids': removed_trial_ids,
                        'updated_trials': updated_trials,
                        'total_trials': len(current_trials)
                    })

            last_trials = current_trial_dict
            await asyncio.sleep(interval_seconds)

        except Exception as e:
            print(f"Error monitoring trials: {e}")
            await asyncio.sleep(interval_seconds)

# Usage
async def trial_change_callback(changes):
    print(f"Trial changes detected at {changes['timestamp']}")
    if changes['new_trials']:
        print(f"  New trials: {[t['name'] for t in changes['new_trials']]}")
    if changes['removed_trial_ids']:
        print(f"  Removed trials: {changes['removed_trial_ids']}")
    if changes['updated_trials']:
        print(f"  Updated trials: {[t['name'] for t in changes['updated_trials']]}")

# Start monitoring
asyncio.create_task(monitor_trial_changes(trials_api, trial_change_callback))