"""Button platform for Reticulum (per identity)."""

from __future__ import annotations

import logging

from homeassistant.components.button import ButtonDeviceClass, ButtonEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback

from .const import DOMAIN, SUBENTRY_TYPE_IDENTITY
from .entity import ReticulumIdentityEntity
from .reticulum_client import ReticulumError

_LOGGER = logging.getLogger(__name__)


async def async_setup_entry(
    hass: HomeAssistant,
    entry: ConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up per-identity buttons."""
    runtime = hass.data[DOMAIN][entry.entry_id]
    for subentry in entry.subentries.values():
        if subentry.subentry_type != SUBENTRY_TYPE_IDENTITY:
            continue
        manager = runtime.identities.get(subentry.subentry_id)
        if manager is None:
            continue
        async_add_entities(
            [
                ReticulumAnnounceButton(manager, entry, subentry),
                ReticulumSyncButton(manager, entry, subentry),
                ReticulumRegenerateButton(manager, entry, subentry),
            ],
            config_subentry_id=subentry.subentry_id,
        )


class ReticulumAnnounceButton(ReticulumIdentityEntity, ButtonEntity):
    """Announce this identity's LXMF destination."""

    _attr_translation_key = "announce"
    _attr_icon = "mdi:bullhorn"

    def __init__(self, manager, entry, subentry) -> None:
        super().__init__(manager, entry, subentry)
        self._attr_unique_id = f"{subentry.subentry_id}_announce"

    async def async_press(self) -> None:
        try:
            await self._manager.async_announce()
        except ReticulumError as err:
            _LOGGER.warning("Announce failed: %s", err)


class ReticulumSyncButton(ReticulumIdentityEntity, ButtonEntity):
    """Pull queued messages from the propagation node."""

    _attr_translation_key = "sync"
    _attr_icon = "mdi:sync"

    def __init__(self, manager, entry, subentry) -> None:
        super().__init__(manager, entry, subentry)
        self._attr_unique_id = f"{subentry.subentry_id}_sync"

    async def async_press(self) -> None:
        try:
            await self._manager.async_sync_propagation()
        except ReticulumError as err:
            _LOGGER.warning("Propagation sync failed: %s", err)


class ReticulumRegenerateButton(ReticulumIdentityEntity, ButtonEntity):
    """Generate a brand-new identity/address for this identity."""

    _attr_translation_key = "regenerate"
    _attr_icon = "mdi:key-change"
    _attr_device_class = ButtonDeviceClass.RESTART

    def __init__(self, manager, entry, subentry) -> None:
        super().__init__(manager, entry, subentry)
        self._attr_unique_id = f"{subentry.subentry_id}_regenerate"

    async def async_press(self) -> None:
        try:
            address = await self._manager.async_regenerate_identity()
        except ReticulumError as err:
            _LOGGER.warning("Identity regeneration failed: %s", err)
            return
        _LOGGER.info(
            "Identity '%s' regenerated; new address %s",
            self._manager.display_name,
            address,
        )