from __future__ import annotations

import logging
from pathlib import Path

from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.components.http import StaticPathConfig

from .const import DOMAIN
from .coordinator import ZLockCoordinator
from .services import register_services, unregister_services

_LOGGER = logging.getLogger(__name__)

PLATFORMS = ["sensor"]

_CARD_URL = f"/{DOMAIN}/zlock-slots-card.js"
_CARD_PATH = Path(__file__).parent / "frontend" / "zlock-slots-card.js"


async def async_setup(hass: HomeAssistant, config: dict) -> bool:
  hass.data.setdefault(DOMAIN, {})
  return True


async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
  coordinator = ZLockCoordinator(hass, entry)
  await coordinator.async_setup()

  hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator

  await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)

  register_services(hass)
  await _async_register_frontend(hass)

  entry.async_on_unload(entry.add_update_listener(_async_options_updated))

  return True


async def _async_options_updated(hass: HomeAssistant, entry) -> None:
  await hass.config_entries.async_reload(entry.entry_id)


async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
  unloaded = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

  if unloaded:
    coordinator: ZLockCoordinator = hass.data[DOMAIN].pop(entry.entry_id)
    coordinator.async_teardown()

    if not hass.data[DOMAIN]:
      unregister_services(hass)

  return unloaded


async def _async_register_frontend(hass: HomeAssistant) -> None:
  try:
    await hass.http.async_register_static_paths([
      StaticPathConfig(_CARD_URL, str(_CARD_PATH), cache_headers=False)
    ])
  except Exception as err:
    _LOGGER.debug("Static path %s already registered: %s", _CARD_URL, err)

  try:
    lovelace = hass.data["lovelace"]
    resources = lovelace["resources"]
    if not any(r.get("url") == _CARD_URL for r in resources.async_items()):
      await resources.async_create_item({"res_type": "module", "url": _CARD_URL})
    _LOGGER.debug("Registered Lovelace resource: %s", _CARD_URL)
  except Exception as err:
    _LOGGER.error(
      "Failed to register Lovelace card resource %s: %s. "
      "Add it manually: Settings → Dashboards → ⋮ → Resources → Add Resource, "
      "URL: %s, Resource type: JavaScript module.",
      _CARD_URL, err, _CARD_URL,
    )