//! Core types shared across every.channel.

use serde::{Deserialize, Serialize};
use sha3::{Digest, Keccak256};
use std::fmt;

pub const MANIFEST_ID_ALG_BLAKE3: &str = "blake3";
pub const MANIFEST_ID_ALG_KECCAK256: &str = "keccak256";
pub const MERKLE_PROOF_ALG_BLAKE3: &str = "merkle+blake3";
pub const MERKLE_PROOF_ALG_KECCAK256: &str = "merkle+keccak256";

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ChannelId(pub String);

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct DeviceId(pub String);

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct StreamId(pub String);

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ChainCommitment {
    pub chain: String,
    pub scheme: String,
    pub digest: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamDescriptor {
    pub id: StreamId,
    pub title: String,
    pub number: Option<String>,
    pub source: String,
    pub metadata: Vec<StreamMetadata>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub commitments: Vec<ChainCommitment>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamMetadata {
    pub key: String,
    pub value: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BroadcastId {
    pub standard: String,
    pub transport_stream_id: Option<u16>,
    pub program_number: Option<u16>,
    pub virtual_channel: Option<String>,
    pub callsign: Option<String>,
    pub region: Option<String>,
    pub frequency: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SourceId {
    pub kind: String,
    pub device_id: Option<String>,
    pub channel: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamKey {
    pub version: u16,
    pub broadcast: Option<BroadcastId>,
    pub source: Option<SourceId>,
    pub profile: Option<String>,
    pub variant: Option<String>,
}

impl StreamKey {
    pub fn for_channel_or_source(
        channel: Option<&Channel>,
        standard: Option<&str>,
        source: SourceId,
        profile: Option<String>,
        variant: Option<String>,
    ) -> Self {
        let broadcast = channel
            .and_then(|channel| standard.and_then(|standard| channel.broadcast_id(standard)));
        let source = if broadcast.is_some() {
            None
        } else {
            Some(source)
        };

        Self {
            version: 1,
            broadcast,
            source,
            profile,
            variant,
        }
    }

    pub fn to_stream_id(&self) -> StreamId {
        let mut parts = vec![
            "ec".to_string(),
            "stream".to_string(),
            format!("v{}", self.version),
        ];

        if let Some(broadcast) = &self.broadcast {
            parts.push("broadcast".to_string());
            parts.push(sanitize(&broadcast.standard));
            if let Some(tsid) = broadcast.transport_stream_id {
                parts.push(format!("tsid-{tsid}"));
            }
            if let Some(program) = broadcast.program_number {
                parts.push(format!("program-{program}"));
            }
            if let Some(channel) = &broadcast.virtual_channel {
                parts.push(format!("channel-{}", sanitize(channel)));
            }
            if let Some(callsign) = &broadcast.callsign {
                parts.push(format!("callsign-{}", sanitize(callsign)));
            }
            if let Some(region) = &broadcast.region {
                parts.push(format!("region-{}", sanitize(region)));
            }
            if let Some(freq) = &broadcast.frequency {
                parts.push(format!("freq-{}", sanitize(freq)));
            }
        } else if let Some(source) = &self.source {
            parts.push("source".to_string());
            parts.push(sanitize(&source.kind));
            if let Some(device) = &source.device_id {
                parts.push(format!("device-{}", sanitize(device)));
            }
            if let Some(channel) = &source.channel {
                parts.push(format!("channel-{}", sanitize(channel)));
            }
        } else {
            parts.push("unknown".to_string());
        }

        if let Some(profile) = &self.profile {
            parts.push(format!("profile-{}", sanitize(profile)));
        }
        if let Some(variant) = &self.variant {
            parts.push(format!("variant-{}", sanitize(variant)));
        }

        StreamId(parts.join("/"))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Channel {
    pub id: ChannelId,
    pub name: String,
    pub number: Option<String>,
    pub program_id: Option<u16>,
    pub metadata: Vec<ChannelMetadata>,
}

fn sanitize(value: &str) -> String {
    value
        .chars()
        .map(|c| match c {
            'a'..='z' | '0'..='9' | '-' | '_' => c,
            'A'..='Z' => c.to_ascii_lowercase(),
            _ => '_',
        })
        .collect()
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ChannelMetadata {
    Callsign(String),
    Network(String),
    Region(String),
    Frequency(String),
    Extra(String, String),
}

impl BroadcastId {
    pub fn is_usable(&self) -> bool {
        self.transport_stream_id.is_some()
            || self.program_number.is_some()
            || self
                .virtual_channel
                .as_ref()
                .is_some_and(|value| !value.trim().is_empty())
            || self
                .callsign
                .as_ref()
                .is_some_and(|value| !value.trim().is_empty())
    }
}

impl Channel {
    pub fn broadcast_id(&self, standard: &str) -> Option<BroadcastId> {
        let standard = standard.trim().to_ascii_lowercase();
        if standard.is_empty() {
            return None;
        }

        let callsign = channel_metadata_value(&self.metadata, "callsign").or_else(|| {
            let name = self.name.trim();
            (!name.is_empty()).then(|| name.to_string())
        });
        let region = channel_metadata_value(&self.metadata, "region");
        let frequency = channel_metadata_value(&self.metadata, "frequency");
        let transport_stream_id = channel_metadata_u16(&self.metadata, "transport_stream_id")
            .or_else(|| channel_metadata_u16(&self.metadata, "tsid"));
        let program_number = self
            .program_id
            .or_else(|| channel_metadata_u16(&self.metadata, "program_number"))
            .or_else(|| channel_metadata_u16(&self.metadata, "program_id"));
        let virtual_channel = self.number.as_ref().and_then(|value| {
            let trimmed = value.trim();
            (!trimmed.is_empty()).then(|| trimmed.to_string())
        });

        let broadcast = BroadcastId {
            standard,
            transport_stream_id,
            program_number,
            virtual_channel,
            callsign,
            region,
            frequency,
        };

        broadcast.is_usable().then_some(broadcast)
    }
}

fn channel_metadata_value(metadata: &[ChannelMetadata], key: &str) -> Option<String> {
    for item in metadata {
        match item {
            ChannelMetadata::Callsign(value) if key == "callsign" => {
                return Some(value.trim().to_string())
            }
            ChannelMetadata::Region(value) if key == "region" => {
                return Some(value.trim().to_string())
            }
            ChannelMetadata::Frequency(value) if key == "frequency" => {
                return Some(value.trim().to_string())
            }
            ChannelMetadata::Network(value) if key == "network" => {
                return Some(value.trim().to_string())
            }
            ChannelMetadata::Extra(extra_key, value) if extra_key.eq_ignore_ascii_case(key) => {
                let trimmed = value.trim_matches('"').trim().to_string();
                if !trimmed.is_empty() {
                    return Some(trimmed);
                }
            }
            _ => {}
        }
    }
    None
}

fn channel_metadata_u16(metadata: &[ChannelMetadata], key: &str) -> Option<u16> {
    channel_metadata_value(metadata, key).and_then(|value| value.parse().ok())
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PacketDigest {
    pub algorithm: String,
    pub hex: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeterminismProfile {
    pub name: String,
    pub description: String,
    pub encoder: String,
    pub encoder_args: Vec<String>,
    pub chunk_duration_ms: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NodeDescriptor {
    pub node_id: String,
    pub human_name: String,
    pub location_hint: Option<String>,
    pub capabilities: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamEncryptionInfo {
    pub alg: String,
    pub key_id: String,
    pub nonce_scheme: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MoqStreamDescriptor {
    pub endpoint: String,
    pub broadcast_name: String,
    pub track_name: String,
    pub encryption: Option<StreamEncryptionInfo>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamCatalogEntry {
    pub stream: StreamDescriptor,
    pub moq: Option<MoqStreamDescriptor>,
    pub manifest: Option<ManifestSummary>,
    pub updated_unix_ms: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamCatalog {
    pub entries: Vec<StreamCatalogEntry>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum StreamTransportDescriptor {
    /// Stream is available via a MoQ relay over WebTransport/WebSocket.
    RelayMoq {
        url: String,
        broadcast_name: String,
        track_name: String,
    },
    /// Stream is available via iroh direct MoQ.
    IrohDirect {
        endpoint: String,
        broadcast_name: String,
        track_name: String,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamControlAnnouncement {
    pub stream: StreamDescriptor,
    pub transports: Vec<StreamTransportDescriptor>,
    pub updated_unix_ms: u64,
    /// Suggested freshness window for this announcement.
    pub ttl_ms: u64,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub commitments: Vec<ChainCommitment>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ManifestSummary {
    pub manifest_id: String,
    pub merkle_root: String,
    pub epoch_id: String,
    pub total_chunks: u64,
    pub chunk_start_index: u64,
    pub encoder_profile_id: String,
    pub signed_by: Vec<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub commitments: Vec<ChainCommitment>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChunkId {
    pub stream_id: StreamId,
    pub epoch_id: String,
    pub chunk_index: u64,
    pub chunk_hash: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ManifestVariant {
    pub variant_id: String,
    pub stream_id: StreamId,
    pub chunk_start_index: u64,
    pub total_chunks: u64,
    pub merkle_root: String,
    pub chunk_hashes: Vec<String>,
    #[serde(default)]
    pub metadata: Vec<StreamMetadata>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ManifestBody {
    pub stream_id: StreamId,
    pub epoch_id: String,
    pub chunk_duration_ms: u64,
    pub total_chunks: u64,
    pub chunk_start_index: u64,
    pub encoder_profile_id: String,
    pub merkle_root: String,
    pub created_unix_ms: u64,
    pub metadata: Vec<StreamMetadata>,
    pub chunk_hashes: Vec<String>,
    #[serde(default)]
    pub variants: Option<Vec<ManifestVariant>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ManifestSignature {
    pub signer_id: String,
    pub alg: String,
    pub signature: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Manifest {
    pub body: ManifestBody,
    pub manifest_id: String,
    pub signatures: Vec<ManifestSignature>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub commitments: Vec<ChainCommitment>,
}

impl Manifest {
    pub fn summary(&self) -> ManifestSummary {
        ManifestSummary {
            manifest_id: self.manifest_id.clone(),
            merkle_root: self.body.merkle_root.clone(),
            epoch_id: self.body.epoch_id.clone(),
            total_chunks: self.body.total_chunks,
            chunk_start_index: self.body.chunk_start_index,
            encoder_profile_id: self.body.encoder_profile_id.clone(),
            signed_by: self
                .signatures
                .iter()
                .map(|sig| sig.signer_id.clone())
                .collect(),
            commitments: self.commitments.clone(),
        }
    }
}

#[derive(Debug, Clone)]
pub enum ManifestError {
    Empty,
    InvalidHash(String),
}

impl fmt::Display for ManifestError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ManifestError::Empty => write!(f, "no chunk hashes supplied"),
            ManifestError::InvalidHash(value) => write!(f, "invalid chunk hash: {value}"),
        }
    }
}

impl std::error::Error for ManifestError {}

impl ManifestBody {
    pub fn manifest_id(&self) -> Result<String, serde_json::Error> {
        self.manifest_id_blake3()
    }

    pub fn manifest_id_blake3(&self) -> Result<String, serde_json::Error> {
        let bytes = serde_json::to_vec(self)?;
        Ok(blake3::hash(&bytes).to_hex().to_string())
    }

    pub fn manifest_id_keccak256(&self) -> Result<String, serde_json::Error> {
        let bytes = serde_json::to_vec(self)?;
        Ok(hex::encode(keccak256(&bytes)))
    }
}

fn parse_hash32(value: &str) -> Result<[u8; 32], ManifestError> {
    let trimmed = value.trim().strip_prefix("0x").unwrap_or(value.trim());
    let bytes = hex::decode(trimmed).map_err(|_| ManifestError::InvalidHash(value.to_string()))?;
    if bytes.len() != 32 {
        return Err(ManifestError::InvalidHash(value.to_string()));
    }
    let mut out = [0u8; 32];
    out.copy_from_slice(&bytes);
    Ok(out)
}

fn keccak256(bytes: &[u8]) -> [u8; 32] {
    let mut hasher = Keccak256::new();
    hasher.update(bytes);
    let digest = hasher.finalize();
    let mut out = [0u8; 32];
    out.copy_from_slice(&digest);
    out
}

fn blake3_pair_hash(left: &[u8; 32], right: &[u8; 32]) -> [u8; 32] {
    let mut hasher = blake3::Hasher::new();
    hasher.update(left);
    hasher.update(right);
    *hasher.finalize().as_bytes()
}

fn keccak_pair_hash(left: &[u8; 32], right: &[u8; 32]) -> [u8; 32] {
    let mut merged = [0u8; 64];
    merged[..32].copy_from_slice(left);
    merged[32..].copy_from_slice(right);
    keccak256(&merged)
}

fn merkle_root_from_hashes_with(
    hashes: &[String],
    pair_hash: fn(&[u8; 32], &[u8; 32]) -> [u8; 32],
) -> Result<String, ManifestError> {
    if hashes.is_empty() {
        return Err(ManifestError::Empty);
    }
    let mut nodes: Vec<[u8; 32]> = Vec::with_capacity(hashes.len());
    for hash in hashes {
        nodes.push(parse_hash32(hash)?);
    }
    while nodes.len() > 1 {
        if nodes.len() % 2 == 1 {
            if let Some(last) = nodes.last().copied() {
                nodes.push(last);
            }
        }
        let mut parents = Vec::with_capacity(nodes.len() / 2);
        for pair in nodes.chunks(2) {
            parents.push(pair_hash(&pair[0], &pair[1]));
        }
        nodes = parents;
    }
    Ok(hex::encode(nodes[0]))
}

pub fn merkle_root_from_hashes(hashes: &[String]) -> Result<String, ManifestError> {
    blake3_merkle_root_from_hashes(hashes)
}

pub fn blake3_merkle_root_from_hashes(hashes: &[String]) -> Result<String, ManifestError> {
    merkle_root_from_hashes_with(hashes, blake3_pair_hash)
}

pub fn keccak_merkle_root_from_hashes(hashes: &[String]) -> Result<String, ManifestError> {
    merkle_root_from_hashes_with(hashes, keccak_pair_hash)
}

fn merkle_proof_for_index_with(
    hashes: &[String],
    index: usize,
    pair_hash: fn(&[u8; 32], &[u8; 32]) -> [u8; 32],
) -> Result<Vec<String>, ManifestError> {
    if hashes.is_empty() {
        return Err(ManifestError::Empty);
    }
    if index >= hashes.len() {
        return Err(ManifestError::InvalidHash(format!(
            "index {index} out of bounds"
        )));
    }

    let mut nodes: Vec<[u8; 32]> = Vec::with_capacity(hashes.len());
    for hash in hashes {
        nodes.push(parse_hash32(hash)?);
    }

    let mut proof = Vec::new();
    let mut pos = index;
    while nodes.len() > 1 {
        if nodes.len() % 2 == 1 {
            if let Some(last) = nodes.last().copied() {
                nodes.push(last);
            }
        }

        let sibling_index = if pos % 2 == 0 { pos + 1 } else { pos - 1 };
        let sibling = nodes
            .get(sibling_index)
            .ok_or_else(|| ManifestError::InvalidHash("missing sibling".to_string()))?;
        proof.push(hex::encode(sibling));

        let mut parents = Vec::with_capacity(nodes.len() / 2);
        for pair in nodes.chunks(2) {
            parents.push(pair_hash(&pair[0], &pair[1]));
        }
        nodes = parents;
        pos /= 2;
    }

    Ok(proof)
}

pub fn merkle_proof_for_index(
    hashes: &[String],
    index: usize,
) -> Result<Vec<String>, ManifestError> {
    blake3_merkle_proof_for_index(hashes, index)
}

pub fn blake3_merkle_proof_for_index(
    hashes: &[String],
    index: usize,
) -> Result<Vec<String>, ManifestError> {
    merkle_proof_for_index_with(hashes, index, blake3_pair_hash)
}

pub fn keccak_merkle_proof_for_index(
    hashes: &[String],
    index: usize,
) -> Result<Vec<String>, ManifestError> {
    merkle_proof_for_index_with(hashes, index, keccak_pair_hash)
}

fn verify_merkle_proof_with(
    leaf_hash: &str,
    mut index: usize,
    branch: &[String],
    expected_root: &str,
    pair_hash: fn(&[u8; 32], &[u8; 32]) -> [u8; 32],
) -> bool {
    let Ok(mut acc) = parse_hash32(leaf_hash) else {
        return false;
    };
    for sibling_hex in branch {
        let Ok(sibling) = parse_hash32(sibling_hex) else {
            return false;
        };
        let (left, right) = if index % 2 == 0 {
            (acc, sibling)
        } else {
            (sibling, acc)
        };
        acc = pair_hash(&left, &right);
        index /= 2;
    }
    match parse_hash32(expected_root) {
        Ok(root) => acc == root,
        Err(_) => false,
    }
}

pub fn verify_merkle_proof(
    leaf_hash: &str,
    index: usize,
    branch: &[String],
    expected_root: &str,
) -> bool {
    verify_blake3_merkle_proof(leaf_hash, index, branch, expected_root)
}

pub fn verify_blake3_merkle_proof(
    leaf_hash: &str,
    index: usize,
    branch: &[String],
    expected_root: &str,
) -> bool {
    verify_merkle_proof_with(leaf_hash, index, branch, expected_root, blake3_pair_hash)
}

pub fn verify_keccak_merkle_proof(
    leaf_hash: &str,
    index: usize,
    branch: &[String],
    expected_root: &str,
) -> bool {
    verify_merkle_proof_with(leaf_hash, index, branch, expected_root, keccak_pair_hash)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn manifest_id_changes_with_body() {
        let body = ManifestBody {
            stream_id: StreamId("s".to_string()),
            epoch_id: "e".to_string(),
            chunk_duration_ms: 2000,
            total_chunks: 1,
            chunk_start_index: 0,
            encoder_profile_id: "p".to_string(),
            merkle_root: "00".repeat(32),
            created_unix_ms: 1,
            metadata: Vec::new(),
            chunk_hashes: vec!["11".repeat(32)],
            variants: None,
        };
        let id1 = body.manifest_id().unwrap();
        let mut body2 = body.clone();
        body2.created_unix_ms = 2;
        let id2 = body2.manifest_id().unwrap();
        assert_ne!(id1, id2);
    }

    #[test]
    fn manifest_id_defaults_to_blake3() {
        let body = ManifestBody {
            stream_id: StreamId("s".to_string()),
            epoch_id: "e".to_string(),
            chunk_duration_ms: 2000,
            total_chunks: 1,
            chunk_start_index: 0,
            encoder_profile_id: "p".to_string(),
            merkle_root: "00".repeat(32),
            created_unix_ms: 1,
            metadata: Vec::new(),
            chunk_hashes: vec!["11".repeat(32)],
            variants: None,
        };
        let bytes = serde_json::to_vec(&body).unwrap();
        assert_eq!(
            body.manifest_id().unwrap(),
            blake3::hash(&bytes).to_hex().to_string()
        );
        assert_ne!(
            body.manifest_id().unwrap(),
            body.manifest_id_keccak256().unwrap()
        );
    }

    #[test]
    fn merkle_root_single_is_leaf() {
        let leaf = blake3::hash(b"leaf").to_hex().to_string();
        let root = merkle_root_from_hashes(&[leaf.clone()]).unwrap();
        assert_eq!(root, leaf);
        let keccak_root = keccak_merkle_root_from_hashes(&[leaf.clone()]).unwrap();
        assert_eq!(keccak_root, leaf);
    }

    #[test]
    fn merkle_root_rejects_invalid_hash() {
        let err = merkle_root_from_hashes(&["not-hex".to_string()]).unwrap_err();
        assert!(matches!(err, ManifestError::InvalidHash(_)));
    }

    #[test]
    fn merkle_proof_roundtrip_small_sets() {
        for size in 1..=9usize {
            let leaves = (0..size)
                .map(|i| blake3::hash(&[i as u8]).to_hex().to_string())
                .collect::<Vec<_>>();
            let root = merkle_root_from_hashes(&leaves).unwrap();
            for idx in 0..size {
                let proof = merkle_proof_for_index(&leaves, idx).unwrap();
                assert!(
                    verify_merkle_proof(&leaves[idx], idx, &proof, &root),
                    "size {size} idx {idx} failed"
                );
            }
        }
    }

    #[test]
    fn keccak_merkle_proof_roundtrip_small_sets() {
        for size in 1..=9usize {
            let leaves = (0..size)
                .map(|i| blake3::hash(&[i as u8]).to_hex().to_string())
                .collect::<Vec<_>>();
            let root = keccak_merkle_root_from_hashes(&leaves).unwrap();
            for idx in 0..size {
                let proof = keccak_merkle_proof_for_index(&leaves, idx).unwrap();
                assert!(
                    verify_keccak_merkle_proof(&leaves[idx], idx, &proof, &root),
                    "size {size} idx {idx} failed"
                );
            }
        }
    }

    #[test]
    fn merkle_proof_detects_tampering() {
        let leaves = (0..4usize)
            .map(|i| blake3::hash(&[i as u8]).to_hex().to_string())
            .collect::<Vec<_>>();
        let root = merkle_root_from_hashes(&leaves).unwrap();
        let mut proof = merkle_proof_for_index(&leaves, 2).unwrap();
        proof[0] = blake3::hash(b"evil").to_hex().to_string();
        assert!(!verify_merkle_proof(&leaves[2], 2, &proof, &root));
    }

    #[test]
    fn channel_broadcast_id_uses_typed_and_extra_metadata() {
        let channel = Channel {
            id: ChannelId("kcbs".to_string()),
            name: "KCBS-HD".to_string(),
            number: Some("2.1".to_string()),
            program_id: Some(3),
            metadata: vec![
                ChannelMetadata::Callsign("KCBS".to_string()),
                ChannelMetadata::Region("los-angeles".to_string()),
                ChannelMetadata::Extra("tsid".to_string(), "42".to_string()),
                ChannelMetadata::Extra("frequency".to_string(), "573000000".to_string()),
            ],
        };

        let broadcast = channel.broadcast_id("ATSC").unwrap();
        assert_eq!(broadcast.standard, "atsc");
        assert_eq!(broadcast.transport_stream_id, Some(42));
        assert_eq!(broadcast.program_number, Some(3));
        assert_eq!(broadcast.virtual_channel.as_deref(), Some("2.1"));
        assert_eq!(broadcast.callsign.as_deref(), Some("KCBS"));
        assert_eq!(broadcast.region.as_deref(), Some("los-angeles"));
        assert_eq!(broadcast.frequency.as_deref(), Some("573000000"));
    }

    #[test]
    fn stream_key_prefers_broadcast_scope_when_channel_identity_exists() {
        let channel = Channel {
            id: ChannelId("kcbs".to_string()),
            name: "KCBS-HD".to_string(),
            number: Some("2.1".to_string()),
            program_id: None,
            metadata: vec![ChannelMetadata::Callsign("KCBS".to_string())],
        };
        let source = SourceId {
            kind: "hdhr".to_string(),
            device_id: Some("ABCDEF01".to_string()),
            channel: Some("2.1".to_string()),
        };

        let key = StreamKey::for_channel_or_source(
            Some(&channel),
            Some("atsc"),
            source,
            Some("chunk-2000ms".to_string()),
            None,
        );

        assert!(key.broadcast.is_some());
        assert!(key.source.is_none());
        assert_eq!(
            key.to_stream_id().0,
            "ec/stream/v1/broadcast/atsc/channel-2_1/callsign-kcbs/profile-chunk-2000ms"
        );
    }

    #[test]
    fn stream_key_falls_back_to_source_scope_without_channel_identity() {
        let channel = Channel {
            id: ChannelId("unknown".to_string()),
            name: "".to_string(),
            number: None,
            program_id: None,
            metadata: Vec::new(),
        };
        let source = SourceId {
            kind: "ts".to_string(),
            device_id: None,
            channel: Some("file.ts".to_string()),
        };

        let key = StreamKey::for_channel_or_source(
            Some(&channel),
            Some("atsc"),
            source,
            Some("chunk-2000ms".to_string()),
            None,
        );

        assert!(key.broadcast.is_none());
        assert_eq!(
            key.to_stream_id().0,
            "ec/stream/v1/source/ts/channel-file_ts/profile-chunk-2000ms"
        );
    }
}