import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from modAL import ActiveLearner
from modAL.uncertainty import uncertainty_sampling, margin_sampling

class ActiveLearningSystem:
    def __init__(self, initial_labeled_pool, unlabeled_pool, query_strategy='uncertainty'):
        self.labeled_X, self.labeled_y = initial_labeled_pool
        self.unlabeled_X = unlabeled_pool
        self.query_strategies = {
            'uncertainty': uncertainty_sampling,
            'margin': margin_sampling,
            'entropy': self.entropy_sampling
        }

        # Initialize active learner
        self.learner = ActiveLearner(
            estimator=RandomForestClassifier(n_estimators=100, random_state=42),
            query_strategy=self.query_strategies[query_strategy],
            X_training=self.labeled_X,
            y_training=self.labeled_y
        )

    def entropy_sampling(self, classifier, X_pool):
        """Custom entropy-based uncertainty sampling"""
        probas = classifier.predict_proba(X_pool)
        entropy = -np.sum(probas * np.log(probas + 1e-10), axis=1)
        return np.argmax(entropy), X_pool[np.argmax(entropy)]

    def query_and_update(self, batch_size=10, oracle_func=None):
        """Query most informative samples and update model"""
        if len(self.unlabeled_X) == 0:
            return None

        # Query strategy with batch selection
        query_indices = []
        temp_unlabeled = self.unlabeled_X.copy()

        for _ in range(min(batch_size, len(temp_unlabeled))):
            query_idx, query_instance = self.learner.query(temp_unlabeled)
            actual_idx = np.where((self.unlabeled_X == query_instance).all(axis=1))[0][0]
            query_indices.append(actual_idx)
            temp_unlabeled = np.delete(temp_unlabeled, query_idx, axis=0)

        # Get labels from oracle (human annotator or ground truth)
        queried_X = self.unlabeled_X[query_indices]
        if oracle_func:
            queried_y = oracle_func(queried_X)
        else:
            queried_y = self.simulate_oracle(queried_X)

        # Update learner and pools
        self.learner.teach(queried_X, queried_y)
        self.unlabeled_X = np.delete(self.unlabeled_X, query_indices, axis=0)

        return query_indices, queried_X, queried_y

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC

class CommitteeActiveLearner:
    def __init__(self, X_initial, y_initial):
        self.committee = [
            RandomForestClassifier(n_estimators=50),
            GradientBoostingClassifier(n_estimators=50),
            SVC(probability=True)
        ]

        for classifier in self.committee:
            classifier.fit(X_initial, y_initial)

    def query_by_committee(self, X_pool, n_instances=1):
        """Select instances with highest committee disagreement"""
        disagreements = []

        for x in X_pool:
            predictions = [clf.predict_proba([x])[0] for clf in self.committee]
            # Calculate vote entropy (disagreement measure)
            avg_pred = np.mean(predictions, axis=0)
            disagreement = -np.sum(avg_pred * np.log(avg_pred + 1e-10))
            disagreements.append(disagreement)

        # Select top disagreement instances
        selected_indices = np.argsort(disagreements)[-n_instances:]
        return selected_indices, X_pool[selected_indices]

from sklearn.cluster import KMeans
from sklearn.metrics.pairwise import pairwise_distances

def diverse_uncertainty_sampling(classifier, X_pool, X_labeled, n_instances=10, alpha=0.7):
    """Combine uncertainty with diversity for batch selection"""
    # Get uncertainty scores
    probas = classifier.predict_proba(X_pool)
    uncertainties = 1 - np.max(probas, axis=1)

    # Calculate diversity (distance from labeled examples)
    distances = pairwise_distances(X_pool, X_labeled)
    min_distances = np.min(distances, axis=1)

    # Combine uncertainty and diversity
    scores = alpha * uncertainties + (1 - alpha) * min_distances

    # Select top scoring instances
    selected_indices = np.argsort(scores)[-n_instances:]
    return selected_indices

class AnnotationInterface:
    def __init__(self, active_learner):
        self.active_learner = active_learner
        self.annotation_history = []
        self.annotator_confidence = []

    def present_for_annotation(self, instances, context_info=None):
        """Present instances to human annotator with context"""
        annotations = []
        confidences = []

        for i, instance in enumerate(instances):
            print(f"\nAnnotating instance {i+1}/{len(instances)}")
            if context_info:
                print(f"Context: {context_info[i]}")

            # Display instance (adapt based on data type)
            self.display_instance(instance)

            # Get annotation and confidence
            label = self.get_user_input("Label: ")
            confidence = float(self.get_user_input("Confidence (0-1): "))

            annotations.append(label)
            confidences.append(confidence)

        # Store annotation history
        self.annotation_history.extend(list(zip(instances, annotations, confidences)))
        return annotations, confidences

    def get_annotation_quality_feedback(self):
        """Analyze annotation consistency and provide feedback"""
        if len(self.annotation_history) < 10:
            return "Need more annotations for quality analysis"

        recent_confidences = [conf for _, _, conf in self.annotation_history[-10:]]
        avg_confidence = np.mean(recent_confidences)

        if avg_confidence < 0.6:
            return "Consider taking a break or consulting guidelines"
        elif avg_confidence > 0.9:
            return "Great annotation quality! Consider increasing batch size"
        else:
            return "Good annotation quality maintained"

import matplotlib.pyplot as plt

class ActiveLearningMonitor:
    def __init__(self):
        self.performance_history = []
        self.annotation_costs = []
        self.model_uncertainties = []

    def track_performance(self, model, X_test, y_test, n_annotations):
        """Track model performance over annotation iterations"""
        accuracy = accuracy_score(y_test, model.predict(X_test))
        self.performance_history.append(accuracy)
        self.annotation_costs.append(n_annotations)

    def calculate_learning_efficiency(self):
        """Calculate annotation efficiency metrics"""
        if len(self.performance_history) < 2:
            return None

        performance_gains = np.diff(self.performance_history)
        annotation_increments = np.diff(self.annotation_costs)

        efficiency = performance_gains / annotation_increments
        return {
            'current_efficiency': efficiency[-1],
            'average_efficiency': np.mean(efficiency),
            'efficiency_trend': np.polyfit(range(len(efficiency)), efficiency, 1)[0]
        }

    def suggest_stopping_criterion(self):
        """Suggest when to stop active learning"""
        efficiency = self.calculate_learning_efficiency()
        if not efficiency:
            return "Continue learning"

        if efficiency['current_efficiency'] < 0.001:
            return "Consider stopping - low marginal gains"
        elif efficiency['efficiency_trend'] < -0.0001:
            return "Efficiency declining - evaluate stopping soon"
        else:
            return "Continue learning"