sipha_source/

source_file.rs

//! Source file management and position conversion.

use std::io;
use std::path::{Path, PathBuf};

use sipha_core::span::Span;

use crate::content::SourceContent;
use crate::line_map::LineMap;
use crate::position::Position;

/// Represents a source file with efficient line/column conversion.
///
/// `SourceFile` maintains the source content, optional file path, and a cached
/// line map for efficient position conversions.
///
/// # Example
///
/// ```rust
/// use sipha_source::SourceFile;
/// use sipha_core::span::Span;
///
/// let source = SourceFile::new(
///     "fn main() {\n    println!(\"Hello\");\n}".to_string(),
///     None,
/// );
///
/// // Convert byte offset to line/column
/// let pos = source.byte_to_line_col(16).unwrap();
/// assert_eq!(pos.line(), 2);
/// assert_eq!(pos.column(), 5);
///
/// // Extract source text for a span
/// let span = Span::new(16, 23);
/// let text = source.extract_span(span).unwrap();
/// assert_eq!(text, "println");
/// ```
#[derive(Clone, Debug)]
pub struct SourceFile {
    /// The source content (UTF-8 or binary).
    content: SourceContent,
    /// Optional file path.
    path: Option<PathBuf>,
    /// Cached line map for efficient lookups.
    line_map: LineMap,
    /// Whether to use UTF-8 character-based column calculation.
    /// If false, columns are byte-based (for non-UTF-8 content).
    utf8_columns: bool,
}

/// A source code snippet with context lines.
///
/// Used for displaying error messages with surrounding context.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SourceSnippet {
    /// Lines in the snippet, as (line_number, line_content) pairs.
    /// Line numbers are 1-indexed.
    pub lines: Vec<(usize, String)>,
    /// The span to highlight in the snippet.
    pub highlight_span: Span,
    /// First line number in the snippet (1-indexed).
    pub start_line: usize,
    /// Last line number in the snippet (1-indexed).
    pub end_line: usize,
}

impl SourceFile {
    /// Create a new `SourceFile` from UTF-8 content.
    ///
    /// # Arguments
    ///
    /// * `content` - The source code content (UTF-8)
    /// * `path` - Optional file path
    ///
    /// # Example
    ///
    /// ```rust
    /// use sipha_source::SourceFile;
    ///
    /// let source = SourceFile::new("hello world".to_string(), None);
    /// ```
    pub fn new(content: String, path: Option<PathBuf>) -> Self {
        let line_map = LineMap::new(&content);
        Self {
            content: SourceContent::Utf8(content),
            path,
            line_map,
            utf8_columns: true,
        }
    }

    /// Create a new `SourceFile` from bytes.
    ///
    /// This method supports both UTF-8 and non-UTF-8 content.
    /// For non-UTF-8 content, column calculations will be byte-based.
    ///
    /// # Arguments
    ///
    /// * `content` - The source code content as bytes
    /// * `path` - Optional file path
    ///
    /// # Example
    ///
    /// ```rust
    /// use sipha_source::SourceFile;
    ///
    /// // UTF-8 content
    /// let source = SourceFile::from_bytes(b"hello world".to_vec(), None);
    ///
    /// // Non-UTF-8 content (e.g., Latin-1)
    /// let latin1 = vec![0xE9, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64]; // "é world" in Latin-1
    /// let source = SourceFile::from_bytes(latin1, None);
    /// ```
    pub fn from_bytes(content: Vec<u8>, path: Option<PathBuf>) -> Self {
        let line_map = LineMap::from_bytes(&content);
        // Check if content is valid UTF-8 and convert if so
        if let Ok(utf8_str) = std::str::from_utf8(&content) {
            Self {
                content: SourceContent::Utf8(utf8_str.to_string()),
                path,
                line_map,
                utf8_columns: true,
            }
        } else {
            Self {
                content: SourceContent::Bytes(content),
                path,
                line_map,
                utf8_columns: false,
            }
        }
    }

    /// Load a source file from the filesystem as UTF-8.
    ///
    /// # Arguments
    ///
    /// * `path` - Path to the file to load
    ///
    /// # Errors
    ///
    /// Returns an `io::Error` if the file cannot be read or is not valid UTF-8.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// use sipha_source::SourceFile;
    /// use std::path::Path;
    ///
    /// let source = SourceFile::from_path(Path::new("src/main.rs")).unwrap();
    /// ```
    pub fn from_path(path: &Path) -> Result<Self, io::Error> {
        let content = std::fs::read_to_string(path)?;
        Ok(Self::new(content, Some(path.to_path_buf())))
    }

    /// Load a source file from the filesystem as raw bytes.
    ///
    /// This method supports both UTF-8 and non-UTF-8 files.
    ///
    /// # Arguments
    ///
    /// * `path` - Path to the file to load
    ///
    /// # Errors
    ///
    /// Returns an `io::Error` if the file cannot be read.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// use sipha_source::SourceFile;
    /// use std::path::Path;
    ///
    /// // Load any file, including non-UTF-8
    /// let source = SourceFile::from_path_bytes(Path::new("data.bin")).unwrap();
    /// ```
    pub fn from_path_bytes(path: &Path) -> Result<Self, io::Error> {
        let content = std::fs::read(path)?;
        Ok(Self::from_bytes(content, Some(path.to_path_buf())))
    }

    /// Get the source content as a UTF-8 string, if available.
    ///
    /// Returns `None` if the content is not valid UTF-8.
    pub fn content(&self) -> Option<&str> {
        self.content.as_str()
    }

    /// Get the source content as bytes.
    pub fn content_bytes(&self) -> &[u8] {
        self.content.as_bytes()
    }

    /// Check if the content is UTF-8 encoded.
    pub fn is_utf8(&self) -> bool {
        self.content.is_utf8() && self.utf8_columns
    }

    /// Get the file path, if available.
    pub fn path(&self) -> Option<&Path> {
        self.path.as_deref()
    }

    /// Get the total byte length of the source.
    pub fn byte_len(&self) -> usize {
        self.content.len()
    }

    /// Get the total number of lines in the source.
    pub fn line_count(&self) -> usize {
        self.line_map.line_count()
    }

    /// Get a specific line by line number (1-indexed) as a UTF-8 string.
    ///
    /// Returns the line content without the trailing newline (if present).
    /// Returns `None` if the line number is out of bounds or the line is not valid UTF-8.
    ///
    /// # Example
    ///
    /// ```rust
    /// use sipha_source::SourceFile;
    ///
    /// let source = SourceFile::new("line 1\nline 2\nline 3".to_string(), None);
    /// assert_eq!(source.line(1), Some("line 1"));
    /// assert_eq!(source.line(2), Some("line 2"));
    /// assert_eq!(source.line(4), None);
    /// ```
    pub fn line(&self, line_num: usize) -> Option<&str> {
        if line_num == 0 || line_num > self.line_map.line_count() {
            return None;
        }

        let line_idx = line_num - 1; // Convert to 0-indexed
        let start = self.line_map.line_start(line_idx)?;
        let end = self.line_map.line_end(line_idx)?;

        self.content.try_str_slice(start, end)
    }

    /// Get a specific line by line number (1-indexed) as bytes.
    ///
    /// Returns the line content without the trailing newline (if present).
    /// Returns `None` if the line number is out of bounds.
    ///
    /// # Example
    ///
    /// ```rust
    /// use sipha_source::SourceFile;
    ///
    /// let source = SourceFile::from_bytes(b"line 1\nline 2".to_vec(), None);
    /// let line = source.line_bytes(1).unwrap();
    /// assert_eq!(line, b"line 1");
    /// ```
    pub fn line_bytes(&self, line_num: usize) -> Option<&[u8]> {
        if line_num == 0 || line_num > self.line_map.line_count() {
            return None;
        }

        let line_idx = line_num - 1; // Convert to 0-indexed
        let start = self.line_map.line_start(line_idx)?;
        let end = self.line_map.line_end(line_idx)?;

        Some(&self.content.as_bytes()[start..end])
    }

    /// Convert a byte offset to a line/column position.
    ///
    /// Returns `None` if the byte offset is out of bounds.
    /// For UTF-8 content, column numbers are 1-indexed character positions.
    /// For non-UTF-8 content, column numbers are 1-indexed byte positions.
    ///
    /// # Example
    ///
    /// ```rust
    /// use sipha_source::SourceFile;
    ///
    /// let source = SourceFile::new("hello\nworld".to_string(), None);
    /// let pos = source.byte_to_line_col(6).unwrap();
    /// assert_eq!(pos.line(), 2);
    /// assert_eq!(pos.column(), 1);
    /// ```
    pub fn byte_to_line_col(&self, byte_offset: usize) -> Option<Position> {
        if byte_offset > self.content.len() {
            return None;
        }

        // Find the line containing this byte offset
        let line_idx = self.line_map.byte_to_line(byte_offset)?;
        let line_start = self.line_map.line_start(line_idx)?;

        // Calculate column
        let byte_offset_in_line = byte_offset - line_start;
        let column = if self.utf8_columns {
            // UTF-8: calculate as character position
            if let Some(line_content) = self
                .content
                .try_str_slice(line_start, self.line_map.line_end(line_idx)?)
            {
                line_content
                    .char_indices()
                    .take_while(|(idx, _)| *idx < byte_offset_in_line)
                    .count()
                    + 1 // 1-indexed
            } else {
                // Fallback to byte-based if line is not valid UTF-8
                byte_offset_in_line + 1
            }
        } else {
            // Non-UTF-8: use byte position
            byte_offset_in_line + 1 // 1-indexed
        };

        Some(Position::new(
            line_idx + 1, // 1-indexed line
            column,
            byte_offset,
        ))
    }

    /// Convert a line/column position to a byte offset.
    ///
    /// Returns `None` if the line or column is out of bounds.
    /// For UTF-8 content, column numbers are 1-indexed character positions.
    /// For non-UTF-8 content, column numbers are 1-indexed byte positions.
    ///
    /// # Example
    ///
    /// ```rust
    /// use sipha_source::SourceFile;
    ///
    /// let source = SourceFile::new("hello\nworld".to_string(), None);
    /// let byte_offset = source.line_col_to_byte(2, 1).unwrap();
    /// assert_eq!(byte_offset, 6); // Start of "world"
    /// ```
    pub fn line_col_to_byte(&self, line: usize, col: usize) -> Option<usize> {
        if line == 0 {
            return None;
        }

        let line_idx = line - 1; // Convert to 0-indexed

        // Check if line exists (accounting for trailing newline creating an empty line)
        if line_idx >= self.line_map.line_count() {
            return None;
        }

        let line_start = self.line_map.line_start(line_idx)?;
        let line_end = self.line_map.line_end(line_idx)?;

        // Convert column (1-indexed) to byte offset
        if col == 0 {
            return Some(line_start);
        }

        if self.utf8_columns {
            // UTF-8: convert character position to byte offset
            if let Some(line_content) = self.content.try_str_slice(line_start, line_end) {
                let char_count = line_content.chars().count();

                // If the line is empty and we're asking for column > 1, return None
                if char_count == 0 && col > 1 {
                    return None;
                }

                if col > char_count + 1 {
                    return Some(line_end);
                }

                let target_char_idx = col - 1; // Convert to 0-indexed

                if target_char_idx == 0 {
                    return Some(line_start);
                }

                if target_char_idx >= char_count {
                    return Some(line_end);
                }

                // Find the byte offset for the target character
                for (char_idx, (byte_idx, _)) in line_content.char_indices().enumerate() {
                    if char_idx == target_char_idx {
                        return Some(line_start + byte_idx);
                    }
                }

                Some(line_end)
            } else {
                // Line is not valid UTF-8, fall back to byte-based
                let byte_col = col - 1;
                if byte_col > (line_end - line_start) {
                    Some(line_end)
                } else {
                    Some(line_start + byte_col)
                }
            }
        } else {
            // Non-UTF-8: use byte position directly
            let byte_col = col - 1; // Convert to 0-indexed
            let line_len = line_end - line_start;

            if byte_col > line_len {
                Some(line_end)
            } else {
                Some(line_start + byte_col)
            }
        }
    }

    /// Extract the source text for a span as a UTF-8 string.
    ///
    /// Returns `None` if the span is out of bounds or the span is not valid UTF-8.
    ///
    /// # Example
    ///
    /// ```rust
    /// use sipha_source::SourceFile;
    /// use sipha_core::span::Span;
    ///
    /// let source = SourceFile::new("hello world".to_string(), None);
    /// let span = Span::new(0, 5);
    /// assert_eq!(source.extract_span(span), Some("hello"));
    /// ```
    pub fn extract_span(&self, span: Span) -> Option<&str> {
        if span.end() > self.content.len() {
            return None;
        }
        self.content.try_str_slice(span.start(), span.end())
    }

    /// Extract the source bytes for a span.
    ///
    /// Returns `None` if the span is out of bounds.
    ///
    /// # Example
    ///
    /// ```rust
    /// use sipha_source::SourceFile;
    /// use sipha_core::span::Span;
    ///
    /// let source = SourceFile::from_bytes(b"hello world".to_vec(), None);
    /// let span = Span::new(0, 5);
    /// assert_eq!(source.extract_span_bytes(span), Some(b"hello".as_slice()));
    /// ```
    pub fn extract_span_bytes(&self, span: Span) -> Option<&[u8]> {
        if span.end() > self.content.len() {
            return None;
        }
        Some(&self.content.as_bytes()[span.start()..span.end()])
    }

    /// Extract a source snippet with context lines around a span.
    ///
    /// Returns `None` if the span is out of bounds.
    ///
    /// # Arguments
    ///
    /// * `span` - The span to highlight
    /// * `context_lines` - Number of context lines to include before and after
    ///
    /// # Example
    ///
    /// ```rust
    /// use sipha_source::SourceFile;
    /// use sipha_core::span::Span;
    ///
    /// let source = SourceFile::new(
    ///     "line 1\nline 2\nline 3\nline 4\nline 5".to_string(),
    ///     None,
    /// );
    /// let span = Span::new(14, 19); // "line 3"
    /// let snippet = source.extract_snippet(span, 1).unwrap();
    /// assert_eq!(snippet.start_line, 2);
    /// assert_eq!(snippet.end_line, 4);
    /// ```
    pub fn extract_snippet(&self, span: Span, context_lines: usize) -> Option<SourceSnippet> {
        if span.end() > self.content.len() {
            return None;
        }

        // Find the lines containing the span
        let start_pos = self.byte_to_line_col(span.start())?;
        let end_pos = self.byte_to_line_col(span.end().saturating_sub(1))?;

        let start_line = start_pos.line();
        let end_line = end_pos.line();

        // Expand with context
        let snippet_start_line = start_line.saturating_sub(context_lines);
        let snippet_end_line = (end_line + context_lines).min(self.line_count());

        // Collect lines
        let mut lines = Vec::new();
        for line_num in snippet_start_line..=snippet_end_line {
            if let Some(line_bytes) = self.line_bytes(line_num) {
                // Try to convert to string, or use a placeholder for non-UTF-8
                let line_str = std::str::from_utf8(line_bytes)
                    .map(|s| s.to_string())
                    .unwrap_or_else(|_| format!("<non-UTF-8: {} bytes>", line_bytes.len()));
                lines.push((line_num, line_str));
            }
        }

        Some(SourceSnippet {
            lines,
            highlight_span: span,
            start_line: snippet_start_line,
            end_line: snippet_end_line,
        })
    }
}

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

    #[test]
    fn test_new() {
        let source = SourceFile::new("hello".to_string(), None);
        assert_eq!(source.content(), Some("hello"));
        assert_eq!(source.path(), None);
        assert_eq!(source.byte_len(), 5);
    }

    #[test]
    fn test_with_path() {
        let path = PathBuf::from("test.rs");
        let source = SourceFile::new("hello".to_string(), Some(path.clone()));
        assert_eq!(source.path(), Some(path.as_path()));
    }

    #[test]
    fn test_line() {
        let source = SourceFile::new("line 1\nline 2\nline 3".to_string(), None);
        assert_eq!(source.line(1), Some("line 1"));
        assert_eq!(source.line(2), Some("line 2"));
        assert_eq!(source.line(3), Some("line 3"));
        assert_eq!(source.line(0), None);
        assert_eq!(source.line(4), None);
    }

    #[test]
    fn test_byte_to_line_col() {
        let source = SourceFile::new("hello\nworld".to_string(), None);
        let pos = source.byte_to_line_col(0).unwrap();
        assert_eq!(pos.line(), 1);
        assert_eq!(pos.column(), 1);

        let pos = source.byte_to_line_col(6).unwrap();
        assert_eq!(pos.line(), 2);
        assert_eq!(pos.column(), 1);

        let pos = source.byte_to_line_col(7).unwrap();
        assert_eq!(pos.line(), 2);
        assert_eq!(pos.column(), 2);
    }

    #[test]
    fn test_line_col_to_byte() {
        let source = SourceFile::new("hello\nworld".to_string(), None);
        assert_eq!(source.line_col_to_byte(1, 1), Some(0));
        assert_eq!(source.line_col_to_byte(1, 5), Some(4));
        assert_eq!(source.line_col_to_byte(2, 1), Some(6));
        assert_eq!(source.line_col_to_byte(2, 5), Some(10));
    }

    #[test]
    fn test_extract_span() {
        let source = SourceFile::new("hello world".to_string(), None);
        let span = Span::new(0, 5);
        assert_eq!(source.extract_span(span), Some("hello"));
    }

    #[test]
    fn test_extract_snippet() {
        let content = "line 1\nline 2\nline 3\nline 4\nline 5".to_string();
        let source = SourceFile::new(content, None);
        let span = Span::new(14, 19); // "line 3"
        let snippet = source.extract_snippet(span, 1).unwrap();

        assert_eq!(snippet.start_line, 2);
        assert_eq!(snippet.end_line, 4);
        assert_eq!(snippet.lines.len(), 3);
    }

    #[test]
    fn test_utf8_handling() {
        let source = SourceFile::new("hello 世界\nworld".to_string(), None);
        // "hello 世界" is 5 + 1 + 6 bytes = 12 bytes
        // "hello " is 6 bytes, so "世" starts at byte 6
        let pos = source.byte_to_line_col(6).unwrap();
        assert_eq!(pos.line(), 1);
        assert_eq!(pos.column(), 7); // Character position, not byte

        // Test reverse conversion
        let byte = source.line_col_to_byte(1, 7).unwrap();
        assert_eq!(byte, 6);
    }
}