# aiva/performance_analyzer/scaling_effectiveness_analyzer.py

class ScalingEffectivenessAnalyzer:
    def __init__(self):
        self.previous_cpu_utilization = None
        self.previous_memory_utilization = None

    def analyze_cpu_scaling_effectiveness(self, current_cpu_utilization):
        """Analyzes the effectiveness of CPU scaling actions.

        Args:
            current_cpu_utilization (float): The current CPU utilization percentage.

        Returns:
            float: A value between -1 and 1 representing the effectiveness of CPU scaling.
                   Returns 0 if no previous data is available.
        """
        if self.previous_cpu_utilization is None:
            self.previous_cpu_utilization = current_cpu_utilization
            return 0  # No previous data to compare against

        # Calculate the change in CPU utilization
        cpu_change = self.previous_cpu_utilization - current_cpu_utilization

        # Normalize the change to a range of -1 to 1
        # A larger negative value indicates less effective scaling (CPU utilization increased or didn't decrease enough).
        # A larger positive value indicates more effective scaling (CPU utilization decreased significantly).
        scaling_effectiveness = cpu_change / 100  # Assuming utilization is on a 0-100 scale

        # Clip the value to the range [-1, 1]
        scaling_effectiveness = max(-1, min(scaling_effectiveness, 1))

        self.previous_cpu_utilization = current_cpu_utilization
        return scaling_effectiveness

    def analyze_memory_scaling_effectiveness(self, current_memory_utilization):
        """Analyzes the effectiveness of memory scaling actions.

        Args:
            current_memory_utilization (float): The current memory utilization percentage.

        Returns:
            float: A value between -1 and 1 representing the effectiveness of memory scaling.
                   Returns 0 if no previous data is available.
        """
        if self.previous_memory_utilization is None:
            self.previous_memory_utilization = current_memory_utilization
            return 0  # No previous data to compare against

        # Calculate the change in memory utilization
        memory_change = self.previous_memory_utilization - current_memory_utilization

        # Normalize the change to a range of -1 to 1
        # A larger negative value indicates less effective scaling (memory utilization increased or didn't decrease enough).
        # A larger positive value indicates more effective scaling (memory utilization decreased significantly).
        scaling_effectiveness = memory_change / 100  # Assuming utilization is on a 0-100 scale

        # Clip the value to the range [-1, 1]
        scaling_effectiveness = max(-1, min(scaling_effectiveness, 1))

        self.previous_memory_utilization = current_memory_utilization
        return scaling_effectiveness


if __name__ == '__main__':
    # Example Usage
    analyzer = ScalingEffectivenessAnalyzer()

    # Initial CPU utilization
    initial_cpu = 80
    print(f"Initial CPU Utilization: {initial_cpu}")

    # After scaling, CPU utilization is still high
    current_cpu = 75
    effectiveness = analyzer.analyze_cpu_scaling_effectiveness(current_cpu)
    print(f"Current CPU Utilization: {current_cpu}, Scaling Effectiveness: {effectiveness}")

    # After further scaling, CPU utilization drops significantly
    current_cpu = 40
    effectiveness = analyzer.analyze_cpu_scaling_effectiveness(current_cpu)
    print(f"Current CPU Utilization: {current_cpu}, Scaling Effectiveness: {effectiveness}")

    # Initial memory utilization
    initial_memory = 90
    print(f"Initial Memory Utilization: {initial_memory}")

    # After scaling, memory utilization drops
    current_memory = 60
    effectiveness = analyzer.analyze_memory_scaling_effectiveness(current_memory)
    print(f"Current Memory Utilization: {current_memory}, Scaling Effectiveness: {effectiveness}")