MCP Atlassian

"""Models for Jira SLA calculations."""

from typing import Any

from pydantic import BaseModel


class WorkingHoursConfig(BaseModel):
    """Configuration for working hours."""

    start: str  # Start time in HH:MM format
    end: str  # End time in HH:MM format
    days: list[int]  # Working days (1=Mon, 7=Sun)
    timezone: str  # IANA timezone


class CycleTimeMetric(BaseModel):
    """Cycle time metric (created to resolved)."""

    value_minutes: int | None = None
    formatted: str | None = None
    calculated: bool = False
    reason: str | None = None

    def to_simplified_dict(self) -> dict[str, Any]:
        """Convert to simplified dictionary."""
        result: dict[str, Any] = {"calculated": self.calculated}
        if self.calculated and self.value_minutes is not None:
            result["value_minutes"] = self.value_minutes
            result["formatted"] = self.formatted
        if self.reason:
            result["reason"] = self.reason
        return result


class LeadTimeMetric(BaseModel):
    """Lead time metric (created to now or resolved)."""

    value_minutes: int
    formatted: str
    is_resolved: bool = False

    def to_simplified_dict(self) -> dict[str, Any]:
        """Convert to simplified dictionary."""
        return {
            "value_minutes": self.value_minutes,
            "formatted": self.formatted,
            "is_resolved": self.is_resolved,
        }


class TimeInStatusEntry(BaseModel):
    """Time spent in a single status."""

    status: str
    value_minutes: int
    formatted: str
    percentage: float
    visit_count: int

    def to_simplified_dict(self) -> dict[str, Any]:
        """Convert to simplified dictionary."""
        return {
            "status": self.status,
            "value_minutes": self.value_minutes,
            "formatted": self.formatted,
            "percentage": round(self.percentage, 2),
            "visit_count": self.visit_count,
        }


class TimeInStatusMetric(BaseModel):
    """Time in status breakdown."""

    statuses: list[TimeInStatusEntry]
    total_minutes: int

    def to_simplified_dict(self) -> dict[str, Any]:
        """Convert to simplified dictionary."""
        return {
            "statuses": [s.to_simplified_dict() for s in self.statuses],
            "total_minutes": self.total_minutes,
        }


class DueDateComplianceMetric(BaseModel):
    """Due date compliance metric."""

    status: str  # "met", "missed", "no_due_date", "not_resolved"
    margin_minutes: int | None = None
    formatted_margin: str | None = None

    def to_simplified_dict(self) -> dict[str, Any]:
        """Convert to simplified dictionary."""
        result: dict[str, Any] = {"status": self.status}
        if self.margin_minutes is not None:
            result["margin_minutes"] = self.margin_minutes
            result["formatted_margin"] = self.formatted_margin
        return result


class ResolutionTimeMetric(BaseModel):
    """Resolution time metric (first in progress to resolved)."""

    value_minutes: int | None = None
    formatted: str | None = None
    calculated: bool = False
    reason: str | None = None

    def to_simplified_dict(self) -> dict[str, Any]:
        """Convert to simplified dictionary."""
        result: dict[str, Any] = {"calculated": self.calculated}
        if self.calculated and self.value_minutes is not None:
            result["value_minutes"] = self.value_minutes
            result["formatted"] = self.formatted
        if self.reason:
            result["reason"] = self.reason
        return result


class FirstResponseTimeMetric(BaseModel):
    """First response time metric."""

    value_minutes: int | None = None
    formatted: str | None = None
    calculated: bool = False
    response_type: str | None = None  # "transition", "comment", etc.

    def to_simplified_dict(self) -> dict[str, Any]:
        """Convert to simplified dictionary."""
        result: dict[str, Any] = {"calculated": self.calculated}
        if self.calculated and self.value_minutes is not None:
            result["value_minutes"] = self.value_minutes
            result["formatted"] = self.formatted
            if self.response_type:
                result["response_type"] = self.response_type
        return result


class IssueSLAMetrics(BaseModel):
    """Container for all SLA metrics."""

    cycle_time: CycleTimeMetric | None = None
    lead_time: LeadTimeMetric | None = None
    time_in_status: TimeInStatusMetric | None = None
    due_date_compliance: DueDateComplianceMetric | None = None
    resolution_time: ResolutionTimeMetric | None = None
    first_response_time: FirstResponseTimeMetric | None = None

    def to_simplified_dict(self) -> dict[str, Any]:
        """Convert to simplified dictionary."""
        result: dict[str, Any] = {}
        if self.cycle_time:
            result["cycle_time"] = self.cycle_time.to_simplified_dict()
        if self.lead_time:
            result["lead_time"] = self.lead_time.to_simplified_dict()
        if self.time_in_status:
            result["time_in_status"] = self.time_in_status.to_simplified_dict()
        if self.due_date_compliance:
            result["due_date_compliance"] = (
                self.due_date_compliance.to_simplified_dict()
            )
        if self.resolution_time:
            result["resolution_time"] = self.resolution_time.to_simplified_dict()
        if self.first_response_time:
            result["first_response_time"] = (
                self.first_response_time.to_simplified_dict()
            )
        return result


class IssueSLAResponse(BaseModel):
    """Response containing SLA metrics for a single issue."""

    issue_key: str
    metrics: IssueSLAMetrics
    raw_dates: dict[str, Any] | None = None

    def to_simplified_dict(self) -> dict[str, Any]:
        """Convert to simplified dictionary."""
        result: dict[str, Any] = {
            "issue_key": self.issue_key,
            "metrics": self.metrics.to_simplified_dict(),
        }
        if self.raw_dates:
            result["raw_dates"] = self.raw_dates
        return result


class IssueSLABatchResponse(BaseModel):
    """Response containing SLA metrics for multiple issues."""

    issues: list[IssueSLAResponse]
    total_count: int
    success_count: int
    error_count: int
    errors: list[dict[str, str]]
    metrics_calculated: list[str]
    working_hours_applied: bool
    working_hours_config: WorkingHoursConfig | None = None

    def to_simplified_dict(self) -> dict[str, Any]:
        """Convert to simplified dictionary."""
        result: dict[str, Any] = {
            "issues": [i.to_simplified_dict() for i in self.issues],
            "total_count": self.total_count,
            "success_count": self.success_count,
            "error_count": self.error_count,
            "metrics_calculated": self.metrics_calculated,
            "working_hours_applied": self.working_hours_applied,
        }
        if self.errors:
            result["errors"] = self.errors
        if self.working_hours_config:
            result["working_hours_config"] = {
                "start": self.working_hours_config.start,
                "end": self.working_hours_config.end,
                "days": self.working_hours_config.days,
                "timezone": self.working_hours_config.timezone,
            }
        return result