claude-code-status-line 1.2.2

use crate::colors::SectionColors;
use crate::config::Config;
use crate::render::get_details_and_fg_codes;
use crate::types::{ContextUsageInfo, ContextWindow};

/// Fallback context window size (only used if Claude Code doesn't provide it)
const DEFAULT_CONTEXT_WINDOW: u64 = 200_000;

pub fn calculate_context(
    context_window: Option<&ContextWindow>,
    config: &Config,
) -> Option<ContextUsageInfo> {
    let cw = context_window?;
    let total = cw.context_window_size.unwrap_or(DEFAULT_CONTEXT_WINDOW);
    if total == 0 {
        return None;
    }
    let usage = cw.current_usage.as_ref()?;

    // Calculate content tokens using official method
    // current_tokens = input_tokens + cache_creation_input_tokens + cache_read_input_tokens
    let content_tokens = usage.input_tokens.unwrap_or(0)
        + usage.cache_creation_input_tokens.unwrap_or(0)
        + usage.cache_read_input_tokens.unwrap_or(0);

    // Add autocompact buffer
    let total_used = content_tokens + config.sections.context.autocompact_buffer_size;

    // Raw percentage (matches /context display)
    let percentage = (total_used as f64 / total as f64 * 100.0).min(100.0);

    Some(ContextUsageInfo {
        percentage,
        current_usage_tokens: total_used,
        context_window_size: total,
    })
}

pub fn format_ctx_short(pct: f64, config: &Config) -> String {
    if config.sections.context.show_decimals {
        format!("ctx: ~{:.1}%", pct)
    } else {
        format!("ctx: ~{}%", pct as u64)
    }
}

pub fn format_ctx_full(info: &ContextUsageInfo, colors: &SectionColors, config: &Config) -> String {
    let (details, fg) = get_details_and_fg_codes(colors, config);

    // Format tokens in k (thousands)
    let used_k = info.current_usage_tokens / 1000;
    let total_k = info.context_window_size / 1000;

    let pct_str = if config.sections.context.show_decimals {
        format!("~{:.1}%", info.percentage)
    } else {
        format!("~{}%", info.percentage as u64)
    };

    format!(
        "ctx: {} {}({}k/{}k){}",
        pct_str, details, used_k, total_k, fg
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::{ContextWindow, CurrentUsage};

    #[test]
    fn test_calculate_context_normal() {
        let config = Config::default();
        let cw = ContextWindow {
            context_window_size: Some(200_000),
            current_usage: Some(CurrentUsage {
                input_tokens: Some(50_000),
                _output_tokens: Some(5_000),
                cache_creation_input_tokens: Some(10_000),
                cache_read_input_tokens: Some(5_000),
            }),
        };

        let result = calculate_context(Some(&cw), &config).unwrap();
        assert!(result.percentage > 0.0 && result.percentage <= 100.0);
        assert_eq!(result.context_window_size, 200_000);
        // 50k + 10k + 5k + 45k buffer = 110k
        assert_eq!(result.current_usage_tokens, 110_000);
    }

    #[test]
    fn test_calculate_context_zero_window() {
        let config = Config::default();
        let cw = ContextWindow {
            context_window_size: Some(0),
            current_usage: Some(CurrentUsage {
                input_tokens: Some(100),
                _output_tokens: None,
                cache_creation_input_tokens: None,
                cache_read_input_tokens: None,
            }),
        };

        let result = calculate_context(Some(&cw), &config);
        assert!(result.is_none()); // Should handle zero window
    }

    #[test]
    fn test_calculate_context_missing_window() {
        let config = Config::default();
        let cw = ContextWindow {
            context_window_size: None,
            current_usage: Some(CurrentUsage {
                input_tokens: Some(50_000),
                _output_tokens: None,
                cache_creation_input_tokens: None,
                cache_read_input_tokens: None,
            }),
        };

        let result = calculate_context(Some(&cw), &config).unwrap();
        // Should use DEFAULT_CONTEXT_WINDOW
        assert_eq!(result.context_window_size, DEFAULT_CONTEXT_WINDOW);
    }

    #[test]
    fn test_calculate_context_exceeds_window() {
        let config = Config::default();
        let cw = ContextWindow {
            context_window_size: Some(100_000),
            current_usage: Some(CurrentUsage {
                input_tokens: Some(95_000),
                _output_tokens: None,
                cache_creation_input_tokens: Some(10_000),
                cache_read_input_tokens: None,
            }),
        };

        let result = calculate_context(Some(&cw), &config).unwrap();
        // Should cap at 100%
        assert_eq!(result.percentage, 100.0);
    }

    #[test]
    fn test_calculate_context_all_zeros() {
        let config = Config::default();
        let cw = ContextWindow {
            context_window_size: Some(200_000),
            current_usage: Some(CurrentUsage {
                input_tokens: Some(0),
                _output_tokens: Some(0),
                cache_creation_input_tokens: Some(0),
                cache_read_input_tokens: Some(0),
            }),
        };

        let result = calculate_context(Some(&cw), &config).unwrap();
        // Just buffer, should be low percentage
        assert!(result.percentage < 25.0);
        assert_eq!(result.current_usage_tokens, 45_000); // Just buffer
    }

    #[test]
    fn test_calculate_context_missing_usage() {
        let config = Config::default();
        let cw = ContextWindow {
            context_window_size: Some(200_000),
            current_usage: None,
        };

        let result = calculate_context(Some(&cw), &config);
        assert!(result.is_none());
    }

    #[test]
    fn test_calculate_context_null_tokens() {
        let config = Config::default();
        let cw = ContextWindow {
            context_window_size: Some(200_000),
            current_usage: Some(CurrentUsage {
                input_tokens: None,
                _output_tokens: None,
                cache_creation_input_tokens: None,
                cache_read_input_tokens: None,
            }),
        };

        let result = calculate_context(Some(&cw), &config).unwrap();
        // All None should be treated as 0
        assert_eq!(result.current_usage_tokens, 45_000); // Just buffer
    }

    #[test]
    fn test_format_ctx_short_with_decimals() {
        let mut config = Config::default();
        config.sections.context.show_decimals = true;

        let result = format_ctx_short(42.7, &config);
        assert_eq!(result, "ctx: ~42.7%");
    }

    #[test]
    fn test_format_ctx_short_without_decimals() {
        let mut config = Config::default();
        config.sections.context.show_decimals = false;

        let result = format_ctx_short(42.7, &config);
        assert_eq!(result, "ctx: ~42%");
    }

    #[test]
    fn test_format_ctx_full() {
        let config = Config::default();
        let info = ContextUsageInfo {
            percentage: 55.5,
            current_usage_tokens: 111_000,
            context_window_size: 200_000,
        };

        let result = format_ctx_full(&info, &config.theme.context, &config);
        assert!(result.contains("ctx:"));
        assert!(result.contains("111k"));
        assert!(result.contains("200k"));
    }
}