<?php

declare(strict_types=1);

namespace App\Incident;

enum Severity: string
{
    case Sev1 = 'SEV1';
    case Sev2 = 'SEV2';
    case Sev3 = 'SEV3';
    case Sev4 = 'SEV4';

    public function maxResponseMinutes(): int
    {
        return match ($this) {
            self::Sev1 => 5,
            self::Sev2 => 15,
            self::Sev3 => 60,
            self::Sev4 => 480,
        };
    }

    public function requiresPageOut(): bool
    {
        return match ($this) {
            self::Sev1, self::Sev2 => true,
            self::Sev3, self::Sev4 => false,
        };
    }
}

enum IncidentStatus: string
{
    case Detected = 'detected';
    case Triaged = 'triaged';
    case Investigating = 'investigating';
    case Mitigated = 'mitigated';
    case Resolved = 'resolved';
    case PostmortemPending = 'postmortem_pending';
    case Closed = 'closed';
}

final class Incident
{
    /** @var array<TimelineEntry> */
    private array $timeline = [];
    private IncidentStatus $status;

    public function __construct(
        public readonly string $id,
        public readonly string $title,
        public readonly Severity $severity,
        public readonly \DateTimeImmutable $detectedAt,
        public readonly string $detectedBy,
        private ?string $incidentCommander = null,
    ) {
        $this->status = IncidentStatus::Detected;
        $this->addTimelineEntry('Incident detected', $detectedBy);
    }

    public function assignCommander(string $commander): void
    {
        $this->incidentCommander = $commander;
        $this->addTimelineEntry("Incident Commander assigned: {$commander}", 'system');
    }

    public function updateStatus(IncidentStatus $status, string $updatedBy, string $note = ''): void
    {
        $previousStatus = $this->status;
        $this->status = $status;

        $message = "Status changed: {$previousStatus->value} → {$status->value}";
        if ($note !== '') {
            $message .= " — {$note}";
        }

        $this->addTimelineEntry($message, $updatedBy);
    }

    public function getStatus(): IncidentStatus
    {
        return $this->status;
    }

    /**
     * Calculate time from detection to mitigation.
     */
    public function getTimeToMitigate(): ?int
    {
        $mitigatedEntry = null;

        foreach ($this->timeline as $entry) {
            if (str_contains($entry->message, IncidentStatus::Mitigated->value)) {
                $mitigatedEntry = $entry;
                break;
            }
        }

        if ($mitigatedEntry === null) {
            return null;
        }

        return $mitigatedEntry->timestamp->getTimestamp() - $this->detectedAt->getTimestamp();
    }

    /**
     * Check if response time exceeds SLA.
     */
    public function isResponseOverdue(): bool
    {
        if ($this->status !== IncidentStatus::Detected) {
            return false;
        }

        $elapsedMinutes = (time() - $this->detectedAt->getTimestamp()) / 60;

        return $elapsedMinutes > $this->severity->maxResponseMinutes();
    }

    /** @return array<TimelineEntry> */
    public function getTimeline(): array
    {
        return $this->timeline;
    }

    private function addTimelineEntry(string $message, string $author): void
    {
        $this->timeline[] = new TimelineEntry(
            timestamp: new \DateTimeImmutable(),
            message: $message,
            author: $author,
        );
    }
}

final readonly class TimelineEntry
{
    public function __construct(
        public \DateTimeImmutable $timestamp,
        public string $message,
        public string $author,
    ) {}
}

package incident

import (
	"fmt"
	"strings"
	"sync"
	"time"
)

// Severity represents incident severity levels.
type Severity int

const (
	Sev1 Severity = iota + 1
	Sev2
	Sev3
	Sev4
)

// MaxResponseMinutes returns the max allowed response time.
func (s Severity) MaxResponseMinutes() int {
	switch s {
	case Sev1:
		return 5
	case Sev2:
		return 15
	case Sev3:
		return 60
	default:
		return 480
	}
}

// RequiresPageOut returns true if the severity requires paging.
func (s Severity) RequiresPageOut() bool {
	return s == Sev1 || s == Sev2
}

func (s Severity) String() string {
	return fmt.Sprintf("SEV%d", s)
}

// Status represents incident lifecycle status.
type Status string

const (
	StatusDetected         Status = "detected"
	StatusTriaged          Status = "triaged"
	StatusInvestigating    Status = "investigating"
	StatusMitigated        Status = "mitigated"
	StatusResolved         Status = "resolved"
	StatusPostmortemPending Status = "postmortem_pending"
	StatusClosed           Status = "closed"
)

// TimelineEntry records a point in the incident timeline.
type TimelineEntry struct {
	Timestamp time.Time
	Message   string
	Author    string
}

// Incident tracks an active or resolved incident.
type Incident struct {
	mu                sync.Mutex
	ID                string
	Title             string
	Sev               Severity
	DetectedAt        time.Time
	DetectedBy        string
	IncidentCommander string
	status            Status
	timeline          []TimelineEntry
}

// NewIncident creates a new incident in detected state.
func NewIncident(id, title string, sev Severity, detectedBy string) *Incident {
	inc := &Incident{
		ID:         id,
		Title:      title,
		Sev:        sev,
		DetectedAt: time.Now(),
		DetectedBy: detectedBy,
		status:     StatusDetected,
	}
	inc.addEntry("Incident detected", detectedBy)
	return inc
}

// AssignCommander assigns an incident commander.
func (inc *Incident) AssignCommander(commander string) {
	inc.mu.Lock()
	defer inc.mu.Unlock()
	inc.IncidentCommander = commander
	inc.addEntry(fmt.Sprintf("Incident Commander assigned: %s", commander), "system")
}

// UpdateStatus transitions the incident status.
func (inc *Incident) UpdateStatus(status Status, updatedBy, note string) {
	inc.mu.Lock()
	defer inc.mu.Unlock()
	prev := inc.status
	inc.status = status
	msg := fmt.Sprintf("Status changed: %s -> %s", prev, status)
	if note != "" {
		msg += " -- " + note
	}
	inc.addEntry(msg, updatedBy)
}

// Status returns the current status.
func (inc *Incident) Status() Status {
	inc.mu.Lock()
	defer inc.mu.Unlock()
	return inc.status
}

// TimeToMitigate returns seconds from detection to mitigation, or -1.
func (inc *Incident) TimeToMitigate() int {
	inc.mu.Lock()
	defer inc.mu.Unlock()
	for _, e := range inc.timeline {
		if strings.Contains(e.Message, string(StatusMitigated)) {
			return int(e.Timestamp.Sub(inc.DetectedAt).Seconds())
		}
	}
	return -1
}

// IsResponseOverdue checks if the response time exceeds the SLA.
func (inc *Incident) IsResponseOverdue() bool {
	inc.mu.Lock()
	defer inc.mu.Unlock()
	if inc.status != StatusDetected {
		return false
	}
	elapsed := time.Since(inc.DetectedAt).Minutes()
	return elapsed > float64(inc.Sev.MaxResponseMinutes())
}

func (inc *Incident) addEntry(message, author string) {
	inc.timeline = append(inc.timeline, TimelineEntry{
		Timestamp: time.Now(),
		Message:   message,
		Author:    author,
	})
}

<?php

declare(strict_types=1);

namespace App\Incident;

final readonly class IncidentMetrics
{
    /**
     * @param array<Incident> $incidents Resolved incidents for the period
     * @return array{mttr_hours: float, mttm_minutes: float, count: int, by_severity: array}
     */
    public function calculate(array $incidents): array
    {
        if (empty($incidents)) {
            return [
                'mttr_hours' => 0,
                'mttm_minutes' => 0,
                'count' => 0,
                'by_severity' => [],
            ];
        }

        $totalMitigationSeconds = 0;
        $mitigatedCount = 0;
        $bySeverity = [];

        foreach ($incidents as $incident) {
            $ttm = $incident->getTimeToMitigate();

            if ($ttm !== null) {
                $totalMitigationSeconds += $ttm;
                $mitigatedCount++;
            }

            $sev = $incident->severity->value;
            $bySeverity[$sev] ??= 0;
            $bySeverity[$sev]++;
        }

        return [
            'mttr_hours' => 0, // Requires resolution timestamp
            'mttm_minutes' => $mitigatedCount > 0
                ? round($totalMitigationSeconds / $mitigatedCount / 60, 1)
                : 0,
            'count' => count($incidents),
            'by_severity' => $bySeverity,
        ];
    }
}

package incident

// Metrics computes aggregate incident metrics.
type Metrics struct{}

// MetricsResult holds computed incident metrics.
type MetricsResult struct {
	MTTRHours    float64        `json:"mttr_hours"`
	MTTMMinutes  float64        `json:"mttm_minutes"`
	Count        int            `json:"count"`
	BySeverity   map[string]int `json:"by_severity"`
}

// Calculate computes metrics for a set of resolved incidents.
func (m *Metrics) Calculate(incidents []*Incident) MetricsResult {
	if len(incidents) == 0 {
		return MetricsResult{BySeverity: map[string]int{}}
	}

	var totalMitigationSec int
	mitigatedCount := 0
	bySev := make(map[string]int)

	for _, inc := range incidents {
		ttm := inc.TimeToMitigate()
		if ttm >= 0 {
			totalMitigationSec += ttm
			mitigatedCount++
		}
		bySev[inc.Sev.String()]++
	}

	var mttm float64
	if mitigatedCount > 0 {
		mttm = float64(totalMitigationSec) / float64(mitigatedCount) / 60.0
	}

	return MetricsResult{
		MTTMMinutes: mttm,
		Count:       len(incidents),
		BySeverity:  bySev,
	}
}