# app/models/syndarix/enums.py
"""
Enums for Syndarix domain models.

These enums represent the core state machines and categorizations
used throughout the Syndarix AI consulting platform.
"""

from enum import Enum as PyEnum


class AutonomyLevel(str, PyEnum):
    """
    Defines how much control the human has over agent actions.

    FULL_CONTROL: Human must approve every agent action
    MILESTONE: Human approves at sprint boundaries and major decisions
    AUTONOMOUS: Agents work independently, only escalating critical issues
    """

    FULL_CONTROL = "full_control"
    MILESTONE = "milestone"
    AUTONOMOUS = "autonomous"


class ProjectComplexity(str, PyEnum):
    """
    Project complexity level for estimation and planning.

    SCRIPT: Simple automation or script-level work
    SIMPLE: Straightforward feature or fix
    MEDIUM: Standard complexity with some architectural considerations
    COMPLEX: Large-scale feature requiring significant design work
    """

    SCRIPT = "script"
    SIMPLE = "simple"
    MEDIUM = "medium"
    COMPLEX = "complex"


class ClientMode(str, PyEnum):
    """
    How the client prefers to interact with agents.

    TECHNICAL: Client is technical and prefers detailed updates
    AUTO: Agents automatically determine communication level
    """

    TECHNICAL = "technical"
    AUTO = "auto"


class ProjectStatus(str, PyEnum):
    """
    Project lifecycle status.

    ACTIVE: Project is actively being worked on
    PAUSED: Project is temporarily on hold
    COMPLETED: Project has been delivered successfully
    ARCHIVED: Project is no longer accessible for work
    """

    ACTIVE = "active"
    PAUSED = "paused"
    COMPLETED = "completed"
    ARCHIVED = "archived"


class AgentStatus(str, PyEnum):
    """
    Current operational status of an agent instance.

    IDLE: Agent is available but not currently working
    WORKING: Agent is actively processing a task
    WAITING: Agent is waiting for external input or approval
    PAUSED: Agent has been manually paused
    TERMINATED: Agent instance has been shut down
    """

    IDLE = "idle"
    WORKING = "working"
    WAITING = "waiting"
    PAUSED = "paused"
    TERMINATED = "terminated"


class IssueType(str, PyEnum):
    """
    Issue type for categorization and hierarchy.

    EPIC: Large feature or body of work containing stories
    STORY: User-facing feature or requirement
    TASK: Technical work item
    BUG: Defect or issue to be fixed
    """

    EPIC = "epic"
    STORY = "story"
    TASK = "task"
    BUG = "bug"


class IssueStatus(str, PyEnum):
    """
    Issue workflow status.

    OPEN: Issue is ready to be worked on
    IN_PROGRESS: Agent or human is actively working on the issue
    IN_REVIEW: Work is complete, awaiting review
    BLOCKED: Issue cannot proceed due to dependencies or blockers
    CLOSED: Issue has been completed or cancelled
    """

    OPEN = "open"
    IN_PROGRESS = "in_progress"
    IN_REVIEW = "in_review"
    BLOCKED = "blocked"
    CLOSED = "closed"


class IssuePriority(str, PyEnum):
    """
    Issue priority levels.

    LOW: Nice to have, can be deferred
    MEDIUM: Standard priority, should be done
    HIGH: Important, should be prioritized
    CRITICAL: Must be done immediately, blocking other work
    """

    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"


class SyncStatus(str, PyEnum):
    """
    External issue tracker synchronization status.

    SYNCED: Local and remote are in sync
    PENDING: Local changes waiting to be pushed
    CONFLICT: Merge conflict between local and remote
    ERROR: Synchronization failed due to an error
    """

    SYNCED = "synced"
    PENDING = "pending"
    CONFLICT = "conflict"
    ERROR = "error"


class SprintStatus(str, PyEnum):
    """
    Sprint lifecycle status.

    PLANNED: Sprint has been created but not started
    ACTIVE: Sprint is currently in progress
    IN_REVIEW: Sprint work is done, demo/review pending
    COMPLETED: Sprint has been finished successfully
    CANCELLED: Sprint was cancelled before completion
    """

    PLANNED = "planned"
    ACTIVE = "active"
    IN_REVIEW = "in_review"
    COMPLETED = "completed"
    CANCELLED = "cancelled"


class AgentTypeCategory(str, PyEnum):
    """
    Category classification for agent types.

    Used for grouping and filtering agents in the UI.

    DEVELOPMENT: Product, project, and engineering roles
    DESIGN: UI/UX and design research roles
    QUALITY: QA and security engineering
    OPERATIONS: DevOps and MLOps
    AI_ML: Machine learning and AI specialists
    DATA: Data science and engineering
    LEADERSHIP: Technical leadership roles
    DOMAIN_EXPERT: Industry and domain specialists
    """

    DEVELOPMENT = "development"
    DESIGN = "design"
    QUALITY = "quality"
    OPERATIONS = "operations"
    AI_ML = "ai_ml"
    DATA = "data"
    LEADERSHIP = "leadership"
    DOMAIN_EXPERT = "domain_expert"