from __future__ import annotations


def normalize_fixture(
    payload: dict[str, object], manufacturer_key: str, fixture_key: str
) -> dict[str, object]:
    modes = payload.get("modes", [])
    available_channels = payload.get("availableChannels", {})
    normalized_modes: list[dict[str, object]] = []
    for mode in modes if isinstance(modes, list) else []:
        channels = mode.get("channels", []) if isinstance(mode, dict) else []
        normalized_channels: list[dict[str, object]] = []
        for index, channel in enumerate(channels, start=1):
            if isinstance(channel, str):
                channel_definition = (
                    available_channels.get(channel, {})
                    if isinstance(available_channels, dict)
                    else {}
                )
                capability = (
                    channel_definition.get("capability")
                    if isinstance(channel_definition, dict)
                    else None
                )
                capabilities = (
                    channel_definition.get("capabilities")
                    if isinstance(channel_definition, dict)
                    else None
                )
                channel_capabilities = (
                    capabilities
                    if isinstance(capabilities, list)
                    else [capability]
                    if capability is not None
                    else []
                )
                capability_types = [
                    str(item.get("type", "")).lower()
                    for item in channel_capabilities
                    if isinstance(item, dict)
                ]
                normalized_channels.append(
                    {
                        "index": index,
                        "key": channel,
                        "display_name": channel.replace("-", " ").title(),
                        "precedence": (
                            "htp"
                            if "dim" in channel.lower() or "intensity" in capability_types
                            else "ltp"
                        ),
                        "resolution": 8,
                        "capabilities": channel_capabilities,
                    }
                )
            elif isinstance(channel, dict):
                key = str(
                    channel.get("name", channel.get("key", channel.get("display_name", f"channel-{index}")))
                )
                capability = channel.get("capability")
                capabilities = channel.get("capabilities")
                channel_capabilities = (
                    capabilities
                    if isinstance(capabilities, list)
                    else [capability]
                    if capability is not None
                    else []
                )
                normalized_channels.append(
                    {
                        "index": index,
                        "key": key,
                        "display_name": str(channel.get("display_name", key)),
                        "precedence": str(
                            channel.get(
                                "precedence",
                                "htp" if "dim" in key.lower() else "ltp",
                            )
                        ).lower(),
                        "resolution": int(channel.get("resolution", 8)),
                        "capabilities": channel_capabilities,
                    }
                )
        normalized_modes.append(
            {
                "key": (
                    str(mode.get("name", mode.get("key", "default")))
                    if isinstance(mode, dict)
                    else "default"
                ),
                "channel_count": len(normalized_channels),
                "channels": normalized_channels,
            }
        )
    return {
        "manufacturer": manufacturer_key,
        "model": payload.get("name", fixture_key),
        "short_name": payload.get("shortName"),
        "categories": payload.get("categories", []),
        "modes": normalized_modes,
        "schema_version": payload.get("$schema", "unknown"),
        "source": {
            "manufacturer_key": manufacturer_key,
            "fixture_key": fixture_key,
        },
        "warnings": [],
    }