heroforge_core/sync/

protocol.rs

//! Heroforge sync protocol implementation.
//!
//! This implements the wire protocol for Heroforge synchronization.

use crate::error::Result;
use crate::hash;
use flate2::read::ZlibDecoder;
use flate2::write::ZlibEncoder;
use flate2::Compression;
use std::io::{Read, Write};

/// A card in the Heroforge sync protocol.
#[derive(Debug, Clone)]
pub enum Card {
    /// Login card: login userid nonce signature
    Login {
        userid: String,
        nonce: String,
        signature: String,
    },
    /// Push card: push servercode projectcode
    Push {
        servercode: String,
        projectcode: String,
    },
    /// Pull card: pull servercode projectcode
    Pull {
        servercode: String,
        projectcode: String,
    },
    /// Clone card: clone [protocol-version sequence-number]
    Clone {
        protocol_version: Option<u32>,
        sequence_number: Option<u64>,
    },
    /// File card: file artifact-id [delta-source-id] size \n content
    File {
        artifact_id: String,
        delta_source: Option<String>,
        content: Vec<u8>,
    },
    /// Compressed file card (for clone protocol 3+)
    CFile {
        artifact_id: String,
        delta_source: Option<String>,
        uncompressed_size: usize,
        content: Vec<u8>,
    },
    /// Igot card: igot artifact-id [private-flag]
    Igot {
        artifact_id: String,
        is_private: bool,
    },
    /// Gimme card: gimme artifact-id
    Gimme { artifact_id: String },
    /// Cookie card: cookie payload
    Cookie { payload: String },
    /// Error card: error message
    Error { message: String },
    /// Message card: message text
    Message { text: String },
    /// Pragma card: pragma name value...
    Pragma { name: String, values: Vec<String> },
    /// Comment card: # text
    Comment { text: String },
    /// Private marker (precedes a file card)
    Private,
    /// Clone sequence number response
    CloneSeqNo { sequence_number: u64 },
    /// Request config card
    ReqConfig { name: String },
    /// Config card with content
    Config { name: String, content: Vec<u8> },
}

/// A sync protocol message (request or response).
#[derive(Debug, Clone, Default)]
pub struct Message {
    pub cards: Vec<Card>,
}

impl Message {
    /// Create a new empty message.
    pub fn new() -> Self {
        Self { cards: Vec::new() }
    }

    /// Add a card to the message.
    pub fn add(&mut self, card: Card) {
        self.cards.push(card);
    }

    /// Encode the message to bytes (compressed with size prefix).
    ///
    /// Heroforge's HTTP sync protocol uses a 4-byte big-endian size prefix
    /// (uncompressed size) before the zlib-compressed data.
    pub fn encode(&self) -> Result<Vec<u8>> {
        let text = self.to_text()?;
        let uncompressed_size = text.len() as u32;
        let compressed = compress(text.as_bytes())?;

        // Build result with 4-byte size prefix
        let mut result = Vec::with_capacity(4 + compressed.len());
        result.extend_from_slice(&uncompressed_size.to_be_bytes());
        result.extend_from_slice(&compressed);

        Ok(result)
    }

    /// Encode the message to text (uncompressed, for debugging).
    pub fn to_text(&self) -> Result<String> {
        let mut lines: Vec<String> = Vec::new();

        for card in &self.cards {
            lines.push(card.to_line()?);
        }

        Ok(lines.join(""))
    }

    /// Decode a message from compressed bytes.
    ///
    /// This properly handles binary file content within the message.
    pub fn decode(data: &[u8]) -> Result<Self> {
        let bytes = decompress_bytes(data)?;
        Self::from_bytes(&bytes)
    }

    /// Parse a message from uncompressed bytes.
    ///
    /// This handles binary file/cfile content properly.
    pub fn from_bytes(data: &[u8]) -> Result<Self> {
        let mut message = Message::new();
        let mut pos = 0;

        while pos < data.len() {
            // Skip whitespace
            while pos < data.len()
                && (data[pos] == b' ' || data[pos] == b'\n' || data[pos] == b'\r')
            {
                pos += 1;
            }
            if pos >= data.len() {
                break;
            }

            // Find end of line
            let line_start = pos;
            while pos < data.len() && data[pos] != b'\n' {
                pos += 1;
            }
            let line_end = pos;
            if pos < data.len() {
                pos += 1; // Skip newline
            }

            let line = String::from_utf8_lossy(&data[line_start..line_end]);
            let line = line.trim();
            if line.is_empty() {
                continue;
            }

            let parts: Vec<&str> = line.splitn(2, ' ').collect();
            let op = parts[0];
            let args = parts.get(1).unwrap_or(&"");

            match op {
                "file" | "cfile" => {
                    // file artifact-id size                    (3 parts total, 2 args)
                    // file artifact-id delta-src size          (4 parts total, 3 args)
                    // cfile artifact-id size usize             (4 parts total, 3 args)
                    // cfile artifact-id delta-src size usize   (5 parts total, 4 args)
                    let parts: Vec<&str> = args.split_whitespace().collect();
                    if parts.len() >= 2 {
                        let (artifact_id, delta_source, size) = if op == "cfile" {
                            // cfile: artifact-id [delta-src] size usize
                            // parts[0] = artifact-id
                            // If 4+ parts: parts[1]=delta, parts[2]=size, parts[3]=usize
                            // If 3 parts: parts[1]=size, parts[2]=usize (no delta)
                            if parts.len() >= 4 {
                                (
                                    parts[0].to_string(),
                                    Some(parts[1].to_string()),
                                    parts[2].parse::<usize>().unwrap_or(0),
                                )
                            } else if parts.len() == 3 {
                                (
                                    parts[0].to_string(),
                                    None,
                                    parts[1].parse::<usize>().unwrap_or(0),
                                )
                            } else {
                                continue;
                            }
                        } else {
                            // file: artifact-id [delta-src] size
                            // parts[0] = artifact-id
                            // If 3+ parts: check if parts[1] looks like a hash (delta) or number (size)
                            // If 2 parts: parts[1] = size (no delta)
                            if parts.len() >= 3 {
                                // Could be "artifact delta size" or misparse
                                // Delta source is a 64-char hash, size is a number
                                if parts[1].len() == 64
                                    && parts[1].chars().all(|c| c.is_ascii_hexdigit())
                                {
                                    // parts[1] is a hash -> delta source
                                    (
                                        parts[0].to_string(),
                                        Some(parts[1].to_string()),
                                        parts[2].parse::<usize>().unwrap_or(0),
                                    )
                                } else {
                                    // parts[1] is size, no delta
                                    (
                                        parts[0].to_string(),
                                        None,
                                        parts[1].parse::<usize>().unwrap_or(0),
                                    )
                                }
                            } else {
                                (
                                    parts[0].to_string(),
                                    None,
                                    parts[1].parse::<usize>().unwrap_or(0),
                                )
                            }
                        };

                        // Read the content bytes
                        let content_end = (pos + size).min(data.len());
                        let content = data[pos..content_end].to_vec();
                        pos = content_end;

                        if op == "cfile" {
                            message.add(Card::CFile {
                                artifact_id,
                                delta_source,
                                content,
                                uncompressed_size: parts
                                    .last()
                                    .and_then(|s| s.parse().ok())
                                    .unwrap_or(0),
                            });
                        } else {
                            message.add(Card::File {
                                artifact_id,
                                delta_source,
                                content,
                            });
                        }
                    }
                }
                _ => {
                    // Handle other cards via text parsing
                    if let Some(card) = Self::parse_text_card(op, args) {
                        message.add(card);
                    }
                }
            }
        }

        Ok(message)
    }

    /// Parse a non-file card from text.
    fn parse_text_card(op: &str, args: &str) -> Option<Card> {
        match op {
            "login" => {
                let parts: Vec<&str> = args.split_whitespace().collect();
                if parts.len() >= 3 {
                    Some(Card::Login {
                        userid: decode_fossil_string(parts[0]),
                        nonce: parts[1].to_string(),
                        signature: parts[2].to_string(),
                    })
                } else {
                    None
                }
            }
            "push" => {
                let parts: Vec<&str> = args.split_whitespace().collect();
                if parts.len() >= 2 {
                    Some(Card::Push {
                        servercode: parts[0].to_string(),
                        projectcode: parts[1].to_string(),
                    })
                } else {
                    None
                }
            }
            "pull" => {
                let parts: Vec<&str> = args.split_whitespace().collect();
                if parts.len() >= 2 {
                    Some(Card::Pull {
                        servercode: parts[0].to_string(),
                        projectcode: parts[1].to_string(),
                    })
                } else {
                    None
                }
            }
            "clone" => {
                let parts: Vec<&str> = args.split_whitespace().collect();
                Some(Card::Clone {
                    protocol_version: parts.first().and_then(|s| s.parse().ok()),
                    sequence_number: parts.get(1).and_then(|s| s.parse().ok()),
                })
            }
            "clone_seqno" => Some(Card::CloneSeqNo {
                sequence_number: args.trim().parse().unwrap_or(0),
            }),
            "igot" => {
                let parts: Vec<&str> = args.split_whitespace().collect();
                if !parts.is_empty() {
                    Some(Card::Igot {
                        artifact_id: parts[0].to_string(),
                        is_private: parts.get(1).map(|&s| s == "1").unwrap_or(false),
                    })
                } else {
                    None
                }
            }
            "gimme" => Some(Card::Gimme {
                artifact_id: args.trim().to_string(),
            }),
            "cookie" => Some(Card::Cookie {
                payload: decode_fossil_string(args.trim()),
            }),
            "error" => Some(Card::Error {
                message: decode_fossil_string(args.trim()),
            }),
            "pragma" => {
                let parts: Vec<&str> = args.split_whitespace().collect();
                if !parts.is_empty() {
                    Some(Card::Pragma {
                        name: parts[0].to_string(),
                        values: parts[1..].iter().map(|s| s.to_string()).collect(),
                    })
                } else {
                    None
                }
            }
            _ => {
                // Unknown card type - ignore
                None
            }
        }
    }

    /// Parse a message from uncompressed text.
    pub fn from_text(text: &str) -> Result<Self> {
        let mut message = Message::new();
        let mut lines = text.lines().peekable();

        while let Some(line) = lines.next() {
            let line = line.trim();
            if line.is_empty() {
                continue;
            }

            let parts: Vec<&str> = line.splitn(2, ' ').collect();
            let op = parts[0];
            let args = parts.get(1).unwrap_or(&"");

            match op {
                "login" => {
                    let parts: Vec<&str> = args.split_whitespace().collect();
                    if parts.len() >= 3 {
                        message.add(Card::Login {
                            userid: decode_fossil_string(parts[0]),
                            nonce: parts[1].to_string(),
                            signature: parts[2].to_string(),
                        });
                    }
                }
                "push" => {
                    let parts: Vec<&str> = args.split_whitespace().collect();
                    if parts.len() >= 2 {
                        message.add(Card::Push {
                            servercode: parts[0].to_string(),
                            projectcode: parts[1].to_string(),
                        });
                    }
                }
                "pull" => {
                    let parts: Vec<&str> = args.split_whitespace().collect();
                    if parts.len() >= 2 {
                        message.add(Card::Pull {
                            servercode: parts[0].to_string(),
                            projectcode: parts[1].to_string(),
                        });
                    }
                }
                "clone" => {
                    let parts: Vec<&str> = args.split_whitespace().collect();
                    if parts.len() >= 2 {
                        message.add(Card::Clone {
                            protocol_version: parts[0].parse().ok(),
                            sequence_number: parts[1].parse().ok(),
                        });
                    } else {
                        message.add(Card::Clone {
                            protocol_version: None,
                            sequence_number: None,
                        });
                    }
                }
                "file" => {
                    let parts: Vec<&str> = args.split_whitespace().collect();
                    if parts.len() >= 2 {
                        let (artifact_id, delta_source, _size) = if parts.len() == 2 {
                            (
                                parts[0].to_string(),
                                None,
                                parts[1].parse::<usize>().unwrap_or(0),
                            )
                        } else {
                            (
                                parts[0].to_string(),
                                Some(parts[1].to_string()),
                                parts[2].parse::<usize>().unwrap_or(0),
                            )
                        };

                        // Read inline content - this is tricky with lines iterator
                        // For now, we'll handle this in a more complete parser
                        message.add(Card::File {
                            artifact_id,
                            delta_source,
                            content: Vec::new(), // Content parsed separately
                        });
                    }
                }
                "igot" => {
                    let parts: Vec<&str> = args.split_whitespace().collect();
                    if !parts.is_empty() {
                        let is_private = parts.get(1).map(|&s| s == "1").unwrap_or(false);
                        message.add(Card::Igot {
                            artifact_id: parts[0].to_string(),
                            is_private,
                        });
                    }
                }
                "gimme" => {
                    message.add(Card::Gimme {
                        artifact_id: args.trim().to_string(),
                    });
                }
                "cookie" => {
                    message.add(Card::Cookie {
                        payload: args.to_string(),
                    });
                }
                "error" => {
                    message.add(Card::Error {
                        message: decode_fossil_string(args),
                    });
                }
                "message" => {
                    message.add(Card::Message {
                        text: decode_fossil_string(args),
                    });
                }
                "pragma" => {
                    let parts: Vec<&str> = args.split_whitespace().collect();
                    if !parts.is_empty() {
                        message.add(Card::Pragma {
                            name: parts[0].to_string(),
                            values: parts[1..].iter().map(|s| s.to_string()).collect(),
                        });
                    }
                }
                "private" => {
                    message.add(Card::Private);
                }
                "clone_seqno" => {
                    if let Ok(seq) = args.trim().parse() {
                        message.add(Card::CloneSeqNo {
                            sequence_number: seq,
                        });
                    }
                }
                "reqconfig" => {
                    message.add(Card::ReqConfig {
                        name: args.trim().to_string(),
                    });
                }
                _ if op.starts_with('#') => {
                    message.add(Card::Comment {
                        text: line.to_string(),
                    });
                }
                _ => {
                    // Unknown card type - skip
                }
            }
        }

        Ok(message)
    }

    /// Create a login card with proper signature.
    pub fn create_login(userid: &str, password: &str, payload: &str) -> Card {
        // nonce = SHA1(payload)
        let nonce = hash::sha1_hex(payload.as_bytes());
        // signature = SHA1(nonce + password)
        let sig_input = format!("{}{}", nonce, password);
        let signature = hash::sha1_hex(sig_input.as_bytes());

        Card::Login {
            userid: userid.to_string(),
            nonce,
            signature,
        }
    }
}

impl Card {
    /// Convert a card to its line representation.
    pub fn to_line(&self) -> Result<String> {
        match self {
            Card::Login {
                userid,
                nonce,
                signature,
            } => Ok(format!(
                "login {} {} {}\n",
                encode_fossil_string(userid),
                nonce,
                signature
            )),
            Card::Push {
                servercode,
                projectcode,
            } => Ok(format!("push {} {}\n", servercode, projectcode)),
            Card::Pull {
                servercode,
                projectcode,
            } => Ok(format!("pull {} {}\n", servercode, projectcode)),
            Card::Clone {
                protocol_version,
                sequence_number,
            } => {
                if let (Some(pv), Some(seq)) = (protocol_version, sequence_number) {
                    Ok(format!("clone {} {}\n", pv, seq))
                } else {
                    Ok("clone\n".to_string())
                }
            }
            Card::File {
                artifact_id,
                delta_source,
                content,
            } => {
                if let Some(delta) = delta_source {
                    Ok(format!(
                        "file {} {} {}\n",
                        artifact_id,
                        delta,
                        content.len()
                    ))
                } else {
                    Ok(format!("file {} {}\n", artifact_id, content.len()))
                }
            }
            Card::CFile {
                artifact_id,
                delta_source,
                uncompressed_size,
                content,
            } => {
                if let Some(delta) = delta_source {
                    Ok(format!(
                        "cfile {} {} {} {}\n",
                        artifact_id,
                        delta,
                        uncompressed_size,
                        content.len()
                    ))
                } else {
                    Ok(format!(
                        "cfile {} {} {}\n",
                        artifact_id,
                        uncompressed_size,
                        content.len()
                    ))
                }
            }
            Card::Igot {
                artifact_id,
                is_private,
            } => {
                if *is_private {
                    Ok(format!("igot {} 1\n", artifact_id))
                } else {
                    Ok(format!("igot {}\n", artifact_id))
                }
            }
            Card::Gimme { artifact_id } => Ok(format!("gimme {}\n", artifact_id)),
            Card::Cookie { payload } => Ok(format!("cookie {}\n", payload)),
            Card::Error { message } => Ok(format!("error {}\n", encode_fossil_string(message))),
            Card::Message { text } => Ok(format!("message {}\n", encode_fossil_string(text))),
            Card::Pragma { name, values } => {
                if values.is_empty() {
                    Ok(format!("pragma {}\n", name))
                } else {
                    Ok(format!("pragma {} {}\n", name, values.join(" ")))
                }
            }
            Card::Comment { text } => Ok(format!("{}\n", text)),
            Card::Private => Ok("private\n".to_string()),
            Card::CloneSeqNo { sequence_number } => {
                Ok(format!("clone_seqno {}\n", sequence_number))
            }
            Card::ReqConfig { name } => Ok(format!("reqconfig {}\n", name)),
            Card::Config { name, content } => Ok(format!("config {} {}\n", name, content.len())),
        }
    }

    /// Get file content bytes for file/cfile cards.
    pub fn content_bytes(&self) -> Option<&[u8]> {
        match self {
            Card::File { content, .. } => Some(content),
            Card::CFile { content, .. } => Some(content),
            Card::Config { content, .. } => Some(content),
            _ => None,
        }
    }
}

/// Encode a string for Heroforge protocol (escape spaces and special chars).
pub fn encode_fossil_string(s: &str) -> String {
    s.replace('\\', "\\\\")
        .replace(' ', "\\s")
        .replace('\n', "\\n")
}

/// Decode a Heroforge-encoded string.
pub fn decode_fossil_string(s: &str) -> String {
    let mut result = String::new();
    let mut chars = s.chars().peekable();

    while let Some(c) = chars.next() {
        if c == '\\' {
            match chars.next() {
                Some('s') => result.push(' '),
                Some('n') => result.push('\n'),
                Some('\\') => result.push('\\'),
                Some(other) => {
                    result.push('\\');
                    result.push(other);
                }
                None => result.push('\\'),
            }
        } else {
            result.push(c);
        }
    }

    result
}

/// Compress data using zlib.
pub fn compress(data: &[u8]) -> Result<Vec<u8>> {
    let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
    encoder.write_all(data)?;
    Ok(encoder.finish()?)
}

/// Get the zlib-compressed data, stripping any size prefix.
fn get_compressed_data(data: &[u8]) -> &[u8] {
    if data.len() >= 5 {
        // Check if this looks like a size prefix followed by zlib header
        // Zlib header starts with 0x78 (deflate with default/max compression)
        if data[4] == 0x78 {
            // Has size prefix, skip it
            return &data[4..];
        }
    }
    if !data.is_empty() && data[0] == 0x78 {
        // No prefix, starts with zlib header directly
        return data;
    }
    // Try as-is
    data
}

/// Decompress zlib data to bytes.
///
/// Heroforge's HTTP sync protocol uses a 4-byte big-endian size prefix
/// before the zlib-compressed data.
pub fn decompress_bytes(data: &[u8]) -> Result<Vec<u8>> {
    let compressed_data = get_compressed_data(data);
    let mut decoder = ZlibDecoder::new(compressed_data);
    let mut result = Vec::new();
    decoder.read_to_end(&mut result)?;
    Ok(result)
}

/// Decompress zlib data to string.
///
/// Heroforge's HTTP sync protocol uses a 4-byte big-endian size prefix
/// before the zlib-compressed data.
#[allow(dead_code)]
pub fn decompress(data: &[u8]) -> Result<String> {
    let compressed_data = get_compressed_data(data);
    let mut decoder = ZlibDecoder::new(compressed_data);
    let mut result = String::new();
    decoder.read_to_string(&mut result)?;
    Ok(result)
}

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

    #[test]
    fn test_encode_decode_string() {
        assert_eq!(encode_fossil_string("hello world"), "hello\\sworld");
        assert_eq!(encode_fossil_string("line1\nline2"), "line1\\nline2");
        assert_eq!(decode_fossil_string("hello\\sworld"), "hello world");
        assert_eq!(decode_fossil_string("line1\\nline2"), "line1\nline2");
    }

    #[test]
    fn test_message_parse() {
        let text = "push abc123 def456\nigot hash1\nigot hash2 1\ngimme hash3\n";
        let msg = Message::from_text(text).unwrap();
        assert_eq!(msg.cards.len(), 4);
    }

    #[test]
    fn test_compress_decompress() {
        let original = "Hello, Heroforge sync protocol!";
        let compressed = compress(original.as_bytes()).unwrap();
        let decompressed = decompress(&compressed).unwrap();
        assert_eq!(decompressed, original);
    }
}