import time
import datetime
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches

print('All imports successful.')

def generate_heartbeat(system_id: str, timestamp: datetime.datetime = None) -> dict:
    """
    Simulates generating a single heartbeat signal.

    Inputs:
    - system_id (str): A unique identifier for the system sending the heartbeat.
    - timestamp (datetime, optional): The time to record for the heartbeat. If None, uses datetime.datetime.now().

    Outputs:
    - dict: A dictionary containing the heartbeat data.
      - 'timestamp' (datetime): The time the heartbeat was generated.
      - 'system_id' (str): The ID of the system.
      - 'status' (str): The current status, typically 'ALIVE'.
    """
    if timestamp is None:
        timestamp = datetime.datetime.now()

    return {
        'timestamp': timestamp,
        'system_id': system_id,
        'status': 'ALIVE'
    }

# Demonstrate generating a heartbeat
sample_heartbeat = generate_heartbeat(system_id="AuthService-01")
print(f"Generated Heartbeat: {sample_heartbeat}")

class HeartbeatMonitor:
    """
    A class to simulate a central heartbeat monitoring system.
    It keeps track of the last received heartbeat for each system_id.
    """
    def __init__(self, heartbeat_timeout_seconds: int = 10):
        """
        Inputs:
        - heartbeat_timeout_seconds (int): Max time allowed without a heartbeat
          before a system is considered DOWN.
        """
        self.last_heartbeats = {}
        self.heartbeat_timeout = datetime.timedelta(seconds=heartbeat_timeout_seconds)
        print(f"Heartbeat Monitor initialized with timeout: {heartbeat_timeout_seconds} seconds.")

    def record_heartbeat(self, heartbeat_data: dict):
        """Records a received heartbeat."""
        self.last_heartbeats[heartbeat_data['system_id']] = heartbeat_data['timestamp']

    def get_system_status(self, system_id: str, check_time: datetime.datetime = None) -> str:
        """
        Returns 'UP', 'DOWN', or 'UNKNOWN' for a given system_id.
        Optionally, check_time can be provided to evaluate status at a specific point in time.
        """
        if check_time is None:
            check_time = datetime.datetime.now() # Use real-time if not provided

        if system_id not in self.last_heartbeats:
            return 'UNKNOWN'
        elapsed = check_time - self.last_heartbeats[system_id]
        return 'DOWN' if elapsed > self.heartbeat_timeout else 'UP'

    def get_all_system_statuses(self, check_time: datetime.datetime = None) -> dict:
        """
        Returns status of all monitored systems.
        Optionally, check_time can be provided to evaluate status at a specific point in time.
        """
        if check_time is None:
            check_time = datetime.datetime.now() # Use real-time if not provided
        return {sid: self.get_system_status(sid, check_time=check_time) for sid in self.last_heartbeats}

print('HeartbeatMonitor class defined.')

# Initialize the monitor with a 5-second timeout
monitor = HeartbeatMonitor(heartbeat_timeout_seconds=5)

# Define mock systems
systems = ['WebServer-01', 'Database-01', 'PaymentService-01']

# Use a single clean status_log with ONE row per (tick, system).
status_log = []  # One row per (tick, system_id)

print("--- Simulating Heartbeats (20 ticks × 1s) ---\n")

# Establish a fixed start time for the simulation to control 'current_time'
simulated_start_time = datetime.datetime.now().replace(microsecond=0) # Round to second for cleaner output
simulated_tick_duration = datetime.timedelta(seconds=1)

for i in range(20): # Increased simulation duration to 20 ticks
    real_time_sleep = 0.5 # A small real-world delay to see output incrementally
    time.sleep(real_time_sleep)

    # Calculate the current simulated time for this tick
    current_sim_time = simulated_start_time + (i * simulated_tick_duration)
    print(f"Simulated Time: {current_sim_time.strftime('%H:%M:%S')}")

    # Step 1: Send heartbeats (with intentional failures)
    for system_id in systems:
        # Database-01 goes offline during simulated ticks 7–12 (6 seconds)
        if system_id == 'Database-01' and 7 <= i <= 12:
            pass
        # PaymentService-01 goes offline from simulated tick 14 onward
        elif system_id == 'PaymentService-01' and i >= 14:
            pass
        else:
            # Pass current_sim_time to generate_heartbeat for consistent timestamps
            monitor.record_heartbeat(generate_heartbeat(system_id, timestamp=current_sim_time))

    # Step 2: Record ONE status row per system AFTER all heartbeats processed
    for system_id in systems:
        # Pass the current_sim_time to get_system_status for accurate historical status
        status = monitor.get_system_status(system_id, check_time=current_sim_time)
        status_log.append({
            'time': current_sim_time,
            'system_id': system_id,
            'monitor_status': status
        })
        print(f"  {system_id}: {status}")

print("\n--- Simulation Complete ---")

# Build clean DataFrame — no mixed rows, no ffill needed
status_df = pd.DataFrame(status_log)

print(f"\nDataFrame shape: {status_df.shape}")
print(status_df.head(9))

print("\nLast recorded heartbeats:")
for sys_id, last_hb_time in monitor.last_heartbeats.items():
    print(f"  {sys_id}: {last_hb_time}")

print("\nFinal System Statuses:")
# Pass the last current_sim_time from the loop to get the final status at the end of the simulation
print(monitor.get_all_system_statuses(check_time=current_sim_time))

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(15, 8))

# Get unique system IDs from the status_df
all_systems = status_df['system_id'].unique()

# Define a color palette for different systems using plt.cm.get_cmap
colors_palette = plt.cm.get_cmap('tab10', len(all_systems))

for i, system_id in enumerate(all_systems):
    single_system_df = status_df[status_df['system_id'] == system_id].copy()

    # Map status to numeric for plotting
    single_system_df['status_numeric'] = single_system_df['monitor_status'].map(
        {'UP': 1, 'DOWN': 0, 'UNKNOWN': np.nan}
    )

    # Plot each system's status timeline
    ax.plot(
        single_system_df['time'],
        single_system_df['status_numeric'],
        drawstyle='steps-post',
        marker='o', markersize=4, linewidth=2,
        color=colors_palette(i), label=f'{system_id} Status'
    )

    # Shade DOWN periods in red for each system
    down_rows = single_system_df[single_system_df['monitor_status'] == 'DOWN']
    for _, row in down_rows.iterrows():
        ax.axvspan(
            row['time'],
            row['time'] + pd.Timedelta(seconds=1), # Shade for 1 second duration
            color='red', alpha=0.15 # Use a lighter alpha for overlaying multiple systems
        )

ax.set_title('Monitored Heartbeat Status Over Time for All Systems', fontsize=14)
ax.set_xlabel('Simulated Time')
ax.set_ylabel('Status')
ax.set_yticks([0, 1])
ax.set_yticklabels(['DOWN (0)', 'UP (1)'], fontsize=11)
ax.set_ylim(-0.3, 1.4)
ax.grid(True, linestyle='--', alpha=0.6)
ax.legend(loc='upper right', bbox_to_anchor=(1.25, 1))
plt.xticks(rotation=20)
plt.tight_layout()
plt.show()

import pandas as pd
import matplotlib.pyplot as plt

# Get the final status for each system from the status_df
# This ensures we use the status as recorded at the last simulated time point
# The .last() method on a groupby object correctly retrieves the last non-null entry for each group
final_statuses = status_df.groupby('system_id')['monitor_status'].last()

plt.figure(figsize=(10, 6))
colors = {'UP': 'green', 'DOWN': 'red', 'UNKNOWN': 'gray'}

# Ensure systems are sorted for consistent plotting if desired
final_statuses = final_statuses.sort_index()

bar_colors = [colors[status] for status in final_statuses.values]

# Create a Series with numeric values for plotting, keeping the system IDs as index
# The height of each bar will be 1, and the color will indicate the status.
plot_data = pd.Series([1] * len(final_statuses), index=final_statuses.index)

plot_data.plot(kind='bar', color=bar_colors)

plt.title('Current Health Status of All Monitored Systems (at end of simulation)')
plt.xlabel('System ID')
plt.ylabel('Status')
plt.yticks([]) # Hide y-axis ticks as labels are on bars
plt.xticks(rotation=45, ha='right')
plt.grid(axis='y', linestyle='--', alpha=0.6)

# Add text labels for status on top of bars
for index, system_id in enumerate(final_statuses.index):
    status_value = final_statuses.loc[system_id]
    # Position the text slightly above the bar (height 1)
    plt.text(index, 0.5, status_value, ha='center', va='center', color='white', fontweight='bold', fontsize=10)

plt.ylim(0, 1.2) # Adjust y-limit to fit the bar and text
plt.tight_layout()
plt.show()