//! Core types shared across every.channel.

use serde::{Deserialize, Serialize};
use std::fmt;

#[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, Serialize, Deserialize)]
pub struct StreamDescriptor {
    pub id: StreamId,
    pub title: String,
    pub number: Option<String>,
    pub source: String,
    pub metadata: Vec<StreamMetadata>,
}

#[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 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 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(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),
}

#[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,
}

#[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>,
}

#[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>,
}

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(),
        }
    }
}

#[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> {
        let bytes = serde_json::to_vec(self)?;
        Ok(blake3::hash(&bytes).to_hex().to_string())
    }
}

pub fn merkle_root_from_hashes(hashes: &[String]) -> Result<String, ManifestError> {
    if hashes.is_empty() {
        return Err(ManifestError::Empty);
    }
    let mut nodes: Vec<blake3::Hash> = Vec::with_capacity(hashes.len());
    for hash in hashes {
        let parsed = blake3::Hash::from_hex(hash.as_bytes())
            .map_err(|_| ManifestError::InvalidHash(hash.clone()))?;
        nodes.push(parsed);
    }
    while nodes.len() > 1 {
        if nodes.len() % 2 == 1 {
            if let Some(last) = nodes.last().cloned() {
                nodes.push(last);
            }
        }
        let mut parents = Vec::with_capacity(nodes.len() / 2);
        for pair in nodes.chunks(2) {
            let left = pair[0].as_bytes();
            let right = pair[1].as_bytes();
            let mut merged = [0u8; 64];
            merged[..32].copy_from_slice(left);
            merged[32..].copy_from_slice(right);
            parents.push(blake3::hash(&merged));
        }
        nodes = parents;
    }
    Ok(nodes[0].to_hex().to_string())
}

pub fn merkle_proof_for_index(
    hashes: &[String],
    index: usize,
) -> 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<blake3::Hash> = Vec::with_capacity(hashes.len());
    for hash in hashes {
        let parsed = blake3::Hash::from_hex(hash.as_bytes())
            .map_err(|_| ManifestError::InvalidHash(hash.clone()))?;
        nodes.push(parsed);
    }

    let mut proof = Vec::new();
    let mut pos = index;
    while nodes.len() > 1 {
        if nodes.len() % 2 == 1 {
            if let Some(last) = nodes.last().cloned() {
                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(sibling.to_hex().to_string());

        let mut parents = Vec::with_capacity(nodes.len() / 2);
        for pair in nodes.chunks(2) {
            let left = pair[0].as_bytes();
            let right = pair[1].as_bytes();
            let mut merged = [0u8; 64];
            merged[..32].copy_from_slice(left);
            merged[32..].copy_from_slice(right);
            parents.push(blake3::hash(&merged));
        }
        nodes = parents;
        pos /= 2;
    }

    Ok(proof)
}

pub fn verify_merkle_proof(
    leaf_hash: &str,
    mut index: usize,
    branch: &[String],
    expected_root: &str,
) -> bool {
    let Ok(mut acc) = blake3::Hash::from_hex(leaf_hash.as_bytes()) else {
        return false;
    };
    for sibling_hex in branch {
        let Ok(sibling) = blake3::Hash::from_hex(sibling_hex.as_bytes()) else {
            return false;
        };
        let (left, right) = if index % 2 == 0 {
            (acc, sibling)
        } else {
            (sibling, acc)
        };
        let mut merged = [0u8; 64];
        merged[..32].copy_from_slice(left.as_bytes());
        merged[32..].copy_from_slice(right.as_bytes());
        acc = blake3::hash(&merged);
        index /= 2;
    }
    acc.to_hex().to_string() == expected_root
}

#[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 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);
    }

    #[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 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));
    }
}