from typing import List, Optional, Annotated, Union
from enum import Enum
from pydantic import BaseModel, Field, validator
import ipaddress


class Protocol(str, Enum):
    """
    Enum для сетевых протоколов UFW.
    """

    TCP = "tcp"
    UDP = "udp"
    BOTH = "both"

    @property
    def protocols(self) -> List[str]:
        """Возвращает список протоколов для использования в команде UFW."""
        return ["tcp", "udp"] if self == Protocol.BOTH else [self.value]


class Action(str, Enum):
    """
    Enum для действий UFW.

    Attributes:
        ALLOW: Разрешить трафик
        DENY: Запретить трафик без уведомления
        REJECT: Запретить трафик с уведомлением отправителю
    """

    ALLOW = "allow"
    DENY = "deny"
    REJECT = "reject"


class Direction(str, Enum):
    """
    Enum для направления трафика UFW.

    Attributes:
        IN: Входящий трафик
        OUT: Исходящий трафик
    """

    IN = "in"
    OUT = "out"


class UFWRule(BaseModel):
    """Модель правила UFW"""

    action: Action
    direction: Direction
    from_ip: str
    to_ip: str
    port: Union[int, str]
    protocol: Protocol
    comment: Optional[str] = None

    @validator("port")
    def validate_port(cls, v):
        """
        Проверяет корректность порта или диапазона портов.

        Args:
            v: Порт (число) или диапазон портов (строка вида "3000:3999")

        Returns:
            Union[int, str]: Валидированное значение порта

        Raises:
            ValueError: Если порт или диапазон портов некорректен
        """
        if isinstance(v, int):
            if not (1 <= v <= 65535):
                raise ValueError(f"Порт должен быть в диапазоне 1-65535, получено: {v}")
            return v
        elif isinstance(v, str):
            try:
                start, end = map(int, v.split(":"))
                if not (1 <= start <= end <= 65535):
                    raise ValueError
                return v
            except (ValueError, TypeError):
                raise ValueError(
                    f"Некорректный диапазон портов: {v}. Формат: start:end, где 1 <= start <= end <= 65535"
                )
        else:
            raise ValueError(
                f"Порт должен быть числом или строкой с диапазоном, получено: {type(v)}"
            )

    @validator("from_ip", "to_ip")
    def validate_ip(cls, v):
        """Проверяет корректность IP адреса"""
        try:
            # Пробуем создать объект IP-сети, что автоматически проверит корректность адреса
            ipaddress.ip_network(v, strict=False)
            return v
        except ValueError:
            raise ValueError(f"Некорректный IP адрес или подсеть: {v}")

    @validator("to_ip")
    def validate_ip_version_compatibility(cls, v, values):
        """Проверяет совместимость версий IP адресов"""
        if "from_ip" not in values:
            return v

        # Определяем версии IP
        from_ip = ipaddress.ip_network(values["from_ip"], strict=False)
        to_ip = ipaddress.ip_network(v, strict=False)

        if isinstance(from_ip, ipaddress.IPv6Network) != isinstance(
            to_ip, ipaddress.IPv6Network
        ):
            raise ValueError(
                "Несовместимые версии IP: нельзя смешивать IPv4 и IPv6 в одном правиле"
            )

        return v

    @validator("action", pre=True)
    def validate_action(cls, v):
        """Приводит значение action к нижнему регистру перед валидацией"""
        if isinstance(v, str):
            return v.lower()
        return v

    @validator("protocol", pre=True)
    def validate_protocol(cls, v):
        """Приводит значение protocol к нижнему регистру перед валидацией"""
        if isinstance(v, str):
            return v.lower()
        return v

    def to_ufw_command(self) -> str:
        """Преобразует правило в команду UFW."""
        cmd_parts = ["ufw"]

        # Добавляем действие
        cmd_parts.append(self.action.value)

        # Добавляем направление
        cmd_parts.append(self.direction.value)

        # Добавляем from с IP
        cmd_parts.extend(["from", self.from_ip])

        # Добавляем to с IP
        cmd_parts.extend(["to", self.to_ip])

        # Добавляем порт и протокол
        port_str = str(self.port)  # Работает как с числами, так и с диапазонами
        cmd_parts.extend(["port", port_str])

        # Добавляем протокол
        proto = self.protocol.value
        if proto == "both":
            cmd_parts.append("proto tcp/udp")
        else:
            cmd_parts.extend(["proto", proto])

        # Добавляем комментарий если есть
        if self.comment:
            cmd_parts.extend(["comment", f"'{self.comment}'"])

        return " ".join(cmd_parts)

    @classmethod
    def from_ufw_output(cls, line: str) -> "UFWRule":
        """
        Создает экземпляр UFWRule из строки вывода команды 'ufw status numbered'.

        Args:
            line: Строка вывода UFW (например, "[1] 80/tcp ALLOW IN 192.168.1.0/24 # Web Server")

        Returns:
            UFWRule: Новый экземпляр правила
        """
        import re

        # Регулярное выражение для разбора строки правила UFW
        pattern = r"""^\s*
            \[\s*(?P<number>\d+)\s*\]\s*
            (?P<port>\d+(?::\d+)?)/(?P<protocol>tcp(?:/udp)?|udp)\s+
            (?P<action>ALLOW|DENY|REJECT)\s+(?P<direction>IN|OUT)\s+
            (?P<from_ip>[\w\d\./]+|\bAnywhere\b)
            (?:\s+\(v6\))?
            (?:\s+\((?:out|in)\))?
            \s*
            (?:\#\s*(?P<comment>.*?))?
            \s*$
        """

        match = re.match(pattern, line, re.VERBOSE | re.IGNORECASE)
        if not match:
            raise ValueError(f"Невозможно разобрать строку правила UFW: {line}")

        groups = match.groupdict()

        # Преобразуем протокол в enum
        proto_str = groups["protocol"].lower()
        protocol = (
            Protocol.BOTH
            if proto_str == "tcp/udp"
            else Protocol.UDP if proto_str == "udp" else Protocol.TCP
        )

        # Преобразуем действие в enum (игнорируем регистр)
        action_str = groups["action"].lower()
        action = (
            Action.ALLOW
            if action_str == "allow"
            else Action.DENY if action_str == "deny" else Action.REJECT
        )

        # Преобразуем направление в enum
        direction_str = groups["direction"].lower()
        direction = Direction.IN if direction_str == "in" else Direction.OUT

        # Обрабатываем IP адреса
        from_ip = groups["from_ip"].strip()
        if from_ip.lower() == "anywhere":
            from_ip = "0.0.0.0/0"

        # Для исходящих правил меняем местами from и to
        to_ip = "0.0.0.0/0"  # По умолчанию anywhere

        # Обрабатываем порт
        port = groups["port"]
        if ":" in port:
            # Оставляем как строку для диапазона
            port = port.strip()
        else:
            # Преобразуем в число для одиночного порта
            port = int(port)

        # Обрабатываем комментарий
        comment = groups.get("comment", "").strip() if groups.get("comment") else None

        return cls(
            action=action,
            direction=direction,
            from_ip=from_ip,
            to_ip=to_ip,
            port=port,
            protocol=protocol,
            comment=comment,
        )


class UFWRulesResponse(BaseModel):
    """
    Модель для представления списка правил UFW.

    Attributes:
        enabled: Включен ли UFW
        rules: Список правил UFW
        total_rules: Общее количество правил
    """

    enabled: bool = Field(..., description="Включен ли UFW")
    rules: List[UFWRule] = Field(default_factory=list, description="Список правил UFW")

    @property
    def total_rules(self) -> int:
        """Возвращает общее количество правил."""
        return len(self.rules)


class UFWStatus(BaseModel):
    """
    Модель для представления статуса UFW.

    Attributes:
        enabled: Включен ли UFW
        message: Сообщение о статусе
        last_checked: Время последней проверки статуса
    """

    enabled: bool = Field(..., description="Включен ли UFW")
    message: str = Field(..., description="Сообщение о статусе")