"""Config flow for Rollease Acmeda Automate Pulse Hub (custom integration)."""

from __future__ import annotations

import logging
from asyncio import timeout
from contextlib import suppress
from typing import Any

import voluptuous as vol
import aiopulse

from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_ID

from .const import DOMAIN

_LOGGER = logging.getLogger(__name__)


class AcmedaFlowHandler(ConfigFlow, domain=DOMAIN):
    """Handle a Acmeda config flow."""

    VERSION = 1

    def __init__(self) -> None:
        """Initialize the config flow."""
        self.discovered_hubs: dict[str, aiopulse.Hub] | None = None

    async def async_step_user(
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
        """Handle a flow initialized by the user."""
        _LOGGER.debug("Starting Acmeda config flow, user_input: %s", user_input)

        # If user selects a discovered hub
        if (
            user_input is not None
            and self.discovered_hubs is not None
            and user_input.get(CONF_ID) in self.discovered_hubs
        ):
            _LOGGER.debug("User selected discovered hub: %s", user_input[CONF_ID])
            return await self.async_create(self.discovered_hubs[user_input[CONF_ID]])

        # Already configured hosts
        already_configured = {
            entry.unique_id for entry in self._async_current_entries()
        }

        # Discover hubs on the network
        hubs: list[aiopulse.Hub] = []
        try:
            with suppress(TimeoutError):
                _LOGGER.info("Discovering Acmeda hubs via aiopulse.Hub.discover()...")
                async with timeout(10):
                    hubs = [
                        hub
                        async for hub in aiopulse.Hub.discover()
                        if hub.id not in already_configured
                    ]
        except Exception as exc:
            _LOGGER.error("Exception during discovery: %s", exc, exc_info=True)

        if not hubs:
            _LOGGER.info("No hubs discovered, showing manual entry form")
            return await self.async_step_manual()

        if len(hubs) == 1:
            _LOGGER.info("Only one hub discovered, proceeding with: %s", hubs[0].host)
            return await self.async_create(hubs[0])

        # Multiple hubs found, let user select
        self.discovered_hubs = {hub.id: hub for hub in hubs}

        return self.async_show_form(
            step_id="user",
            data_schema=vol.Schema(
                {
                    vol.Required(CONF_ID): vol.In(
                        {hub.id: f"{hub.id} ({hub.host})" for hub in hubs}
                    )
                }
            ),
        )

    async def async_step_manual(
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
        """Allow manual entry of the hub host."""
        errors = {}
        if user_input is not None:
            host = user_input[CONF_HOST]
            try:
                _LOGGER.info("Manual step: Creating aiopulse.Hub with host %s", host)
                hub = aiopulse.Hub(host)
                await hub.connect()  # For aiopulse 0.4.x, use connect() to verify
                _LOGGER.info("Manual step: Successfully connected to hub %s (%s)", hub.id, hub.host)
                await self.async_set_unique_id(hub.id, raise_on_progress=False)
                return self.async_create_entry(title=hub.id, data={CONF_HOST: host})
            except Exception as exc:
                _LOGGER.error("Manual step: Failed to connect to hub at %s: %s", host, exc, exc_info=True)
                errors["base"] = "cannot_connect"
        return self.async_show_form(
            step_id="manual",
            data_schema=vol.Schema(
                {
                    vol.Required(CONF_HOST): str,
                }
            ),
            errors=errors,
        )

    async def async_create(self, hub: aiopulse.Hub) -> ConfigFlowResult:
        """Create the Acmeda Hub entry."""
        _LOGGER.info("Creating config entry for hub: %s (%s)", hub.id, hub.host)
        await self.async_set_unique_id(hub.id, raise_on_progress=False)
        return self.async_create_entry(title=hub.id, data={CONF_HOST: hub.host})