hyper_playbook/

logger.rs

use std::fs::{self, OpenOptions};
use std::io::Write;
use std::path::PathBuf;

use serde::{Deserialize, Serialize};

use crate::engine::{TickAction, TickResult};

// ---------------------------------------------------------------------------
// PlaybookTickLog
// ---------------------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlaybookTickLog {
    pub ts: String,
    pub symbol: String,
    pub regime: String,
    pub regime_changed: bool,
    pub fsm_state: String,
    pub action: String,
    pub triggered_rules: Vec<String>,
    // Optional position context
    pub entry_price: Option<f64>,
    pub current_price: Option<f64>,
    pub unrealized_pnl: Option<f64>,
}

// ---------------------------------------------------------------------------
// PlaybookLogger
// ---------------------------------------------------------------------------

pub struct PlaybookLogger {
    log_dir: PathBuf,
    symbol: String,
}

impl PlaybookLogger {
    pub fn new(log_dir: PathBuf, symbol: &str) -> Self {
        Self {
            log_dir,
            symbol: symbol.to_string(),
        }
    }

    /// Log a tick result as one JSONL line.
    pub fn log_tick(
        &self,
        tick: &TickResult,
        current_price: Option<f64>,
        entry_price: Option<f64>,
    ) {
        let unrealized_pnl = match (current_price, entry_price) {
            (Some(curr), Some(entry)) => Some(curr - entry),
            _ => None,
        };

        let action_str = format_action_string(&tick.action);

        let log_entry = PlaybookTickLog {
            ts: chrono::Utc::now().to_rfc3339(),
            symbol: self.symbol.clone(),
            regime: tick.regime.clone(),
            regime_changed: tick.regime_changed,
            fsm_state: tick.fsm_state.clone(),
            action: action_str,
            triggered_rules: tick.triggered_rules.clone(),
            entry_price,
            current_price,
            unrealized_pnl,
        };

        if let Ok(json_line) = serde_json::to_string(&log_entry) {
            let date = chrono::Utc::now().format("%Y-%m-%d").to_string();
            let filename = format!("playbook-{}.jsonl", date);
            let path = self.log_dir.join(filename);

            if let Some(parent) = path.parent() {
                let _ = fs::create_dir_all(parent);
            }

            if let Ok(mut file) = OpenOptions::new().create(true).append(true).open(&path) {
                let _ = writeln!(file, "{}", json_line);
            }
        }
    }

    /// Check if a tick result should trigger a notification.
    pub fn should_notify(tick: &TickResult) -> bool {
        match &tick.action {
            TickAction::None => false,
            TickAction::OrderPlaced { .. } => true,
            TickAction::OrderFilled { .. } => true,
            TickAction::OrderCancelled { .. } => false,
            TickAction::PositionClosed { .. } => true,
            TickAction::ForceClose { .. } => true,
        }
    }

    /// Format a notification message for Discord.
    pub fn format_notification(tick: &TickResult, symbol: &str) -> Option<String> {
        if !Self::should_notify(tick) {
            return None;
        }

        let msg = match &tick.action {
            TickAction::OrderPlaced { side, size, .. } => {
                format!(
                    "\u{1f4ca} **{}** | Order placed: {} {} (regime: {})",
                    symbol, side, size, tick.regime
                )
            }
            TickAction::OrderFilled { entry_price, .. } => {
                format!(
                    "\u{2705} **{}** | Order filled at ${:.2} (regime: {})",
                    symbol, entry_price, tick.regime
                )
            }
            TickAction::PositionClosed { reason } => {
                format!(
                    "\u{1f512} **{}** | Position closed: {} (regime: {})",
                    symbol, reason, tick.regime
                )
            }
            TickAction::ForceClose { reason } => {
                format!(
                    "\u{26a0}\u{fe0f} **{}** | Force close: {} (regime: {})",
                    symbol, reason, tick.regime
                )
            }
            _ => return None,
        };

        // Add regime change info
        if tick.regime_changed {
            let prev = tick.previous_regime.as_deref().unwrap_or("unknown");
            return Some(format!(
                "{}\n\u{1f504} Regime changed: {} \u{2192} {}",
                msg, prev, tick.regime
            ));
        }

        Some(msg)
    }
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

fn format_action_string(action: &TickAction) -> String {
    match action {
        TickAction::None => "none".to_string(),
        TickAction::OrderPlaced {
            order_id,
            side,
            size,
        } => format!("order_placed:{}:{}:{}", order_id, side, size),
        TickAction::OrderFilled {
            position_id,
            entry_price,
        } => format!("order_filled:{}:{}", position_id, entry_price),
        TickAction::OrderCancelled { order_id, reason } => {
            format!("order_cancelled:{}:{}", order_id, reason)
        }
        TickAction::PositionClosed { reason } => format!("position_closed:{}", reason),
        TickAction::ForceClose { reason } => format!("force_close:{}", reason),
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use crate::engine::{TickAction, TickResult};

    fn make_tick(action: TickAction) -> TickResult {
        TickResult {
            regime: "bull".into(),
            regime_changed: false,
            previous_regime: None,
            fsm_state: "Idle".into(),
            action,
            triggered_rules: vec!["signal_a".into()],
        }
    }

    fn make_tick_with_regime_change(action: TickAction) -> TickResult {
        TickResult {
            regime: "bear".into(),
            regime_changed: true,
            previous_regime: Some("bull".into()),
            fsm_state: "Idle".into(),
            action,
            triggered_rules: vec![],
        }
    }

    // 1. PlaybookTickLog serialization roundtrip
    #[test]
    fn test_tick_log_serde_roundtrip() {
        let log = PlaybookTickLog {
            ts: "2026-03-19T00:00:00Z".into(),
            symbol: "BTC-USD".into(),
            regime: "bull".into(),
            regime_changed: true,
            fsm_state: "Idle".into(),
            action: "order_placed:o-1:buy:100".into(),
            triggered_rules: vec!["buy_momentum".into()],
            entry_price: Some(50000.0),
            current_price: Some(51000.0),
            unrealized_pnl: Some(1000.0),
        };

        let json = serde_json::to_string(&log).unwrap();
        let back: PlaybookTickLog = serde_json::from_str(&json).unwrap();

        assert_eq!(back.symbol, "BTC-USD");
        assert_eq!(back.regime, "bull");
        assert!(back.regime_changed);
        assert_eq!(back.action, "order_placed:o-1:buy:100");
        assert_eq!(back.triggered_rules, vec!["buy_momentum".to_string()]);
        assert_eq!(back.entry_price, Some(50000.0));
        assert_eq!(back.current_price, Some(51000.0));
        assert_eq!(back.unrealized_pnl, Some(1000.0));
    }

    // 2. should_notify returns true for OrderPlaced, OrderFilled, PositionClosed, ForceClose
    #[test]
    fn test_should_notify_true_cases() {
        let cases = vec![
            TickAction::OrderPlaced {
                order_id: "o-1".into(),
                side: "buy".into(),
                size: 100.0,
            },
            TickAction::OrderFilled {
                position_id: "p-1".into(),
                entry_price: 50000.0,
            },
            TickAction::PositionClosed {
                reason: "exit_rule".into(),
            },
            TickAction::ForceClose {
                reason: "regime_change".into(),
            },
        ];

        for action in cases {
            let tick = make_tick(action.clone());
            assert!(
                PlaybookLogger::should_notify(&tick),
                "should_notify should be true for {:?}",
                action
            );
        }
    }

    // 3. should_notify returns false for None, OrderCancelled
    #[test]
    fn test_should_notify_false_cases() {
        let cases = vec![
            TickAction::None,
            TickAction::OrderCancelled {
                order_id: "o-1".into(),
                reason: "timeout".into(),
            },
        ];

        for action in cases {
            let tick = make_tick(action.clone());
            assert!(
                !PlaybookLogger::should_notify(&tick),
                "should_notify should be false for {:?}",
                action
            );
        }
    }

    // 4. format_notification returns correct messages
    #[test]
    fn test_format_notification_messages() {
        // OrderPlaced
        let tick = make_tick(TickAction::OrderPlaced {
            order_id: "o-1".into(),
            side: "buy".into(),
            size: 100.0,
        });
        let msg = PlaybookLogger::format_notification(&tick, "BTC-USD").unwrap();
        assert!(msg.contains("BTC-USD"));
        assert!(msg.contains("Order placed"));
        assert!(msg.contains("buy"));
        assert!(msg.contains("100"));

        // OrderFilled
        let tick = make_tick(TickAction::OrderFilled {
            position_id: "p-1".into(),
            entry_price: 50000.0,
        });
        let msg = PlaybookLogger::format_notification(&tick, "BTC-USD").unwrap();
        assert!(msg.contains("Order filled"));
        assert!(msg.contains("50000.00"));

        // PositionClosed
        let tick = make_tick(TickAction::PositionClosed {
            reason: "stop_loss".into(),
        });
        let msg = PlaybookLogger::format_notification(&tick, "BTC-USD").unwrap();
        assert!(msg.contains("Position closed"));
        assert!(msg.contains("stop_loss"));

        // ForceClose
        let tick = make_tick(TickAction::ForceClose {
            reason: "regime_change".into(),
        });
        let msg = PlaybookLogger::format_notification(&tick, "BTC-USD").unwrap();
        assert!(msg.contains("Force close"));
        assert!(msg.contains("regime_change"));

        // None => no notification
        let tick = make_tick(TickAction::None);
        assert!(PlaybookLogger::format_notification(&tick, "BTC-USD").is_none());

        // OrderCancelled => no notification
        let tick = make_tick(TickAction::OrderCancelled {
            order_id: "o-1".into(),
            reason: "timeout".into(),
        });
        assert!(PlaybookLogger::format_notification(&tick, "BTC-USD").is_none());
    }

    // 5. format_notification includes regime change info
    #[test]
    fn test_format_notification_regime_change() {
        let tick = make_tick_with_regime_change(TickAction::ForceClose {
            reason: "regime_change".into(),
        });
        let msg = PlaybookLogger::format_notification(&tick, "ETH-USD").unwrap();
        assert!(msg.contains("Regime changed"));
        assert!(msg.contains("bull"));
        assert!(msg.contains("bear"));
    }

    // 6. log_tick writes JSONL to temp dir
    #[test]
    fn test_log_tick_writes_jsonl() {
        let test_dir = PathBuf::from(format!("/tmp/test-playbook-logs-{}", std::process::id()));
        let _ = std::fs::remove_dir_all(&test_dir);

        let logger = PlaybookLogger::new(test_dir.clone(), "BTC-USD");

        let tick = TickResult {
            regime: "bull".into(),
            regime_changed: false,
            previous_regime: None,
            fsm_state: "InPosition".into(),
            action: TickAction::OrderPlaced {
                order_id: "o-1".into(),
                side: "buy".into(),
                size: 500.0,
            },
            triggered_rules: vec!["buy_momentum".into()],
        };

        logger.log_tick(&tick, Some(51000.0), Some(50000.0));

        // Find the written file
        let entries: Vec<_> = std::fs::read_dir(&test_dir)
            .expect("log dir should exist")
            .filter_map(|e| e.ok())
            .collect();
        assert_eq!(entries.len(), 1, "should have exactly one log file");

        let content = std::fs::read_to_string(entries[0].path()).unwrap();
        let lines: Vec<&str> = content.trim().lines().collect();
        assert_eq!(lines.len(), 1, "should have exactly one JSONL line");

        let parsed: PlaybookTickLog = serde_json::from_str(lines[0]).unwrap();
        assert_eq!(parsed.symbol, "BTC-USD");
        assert_eq!(parsed.regime, "bull");
        assert!(parsed.action.starts_with("order_placed:"));
        assert_eq!(parsed.entry_price, Some(50000.0));
        assert_eq!(parsed.current_price, Some(51000.0));
        assert_eq!(parsed.unrealized_pnl, Some(1000.0));

        // Cleanup
        let _ = std::fs::remove_dir_all(&test_dir);
    }

    // 7. log_tick with None prices produces null pnl
    #[test]
    fn test_log_tick_no_prices() {
        let test_dir = PathBuf::from(format!(
            "/tmp/test-playbook-logs-noprice-{}",
            std::process::id()
        ));
        let _ = std::fs::remove_dir_all(&test_dir);

        let logger = PlaybookLogger::new(test_dir.clone(), "ETH-USD");

        let tick = TickResult {
            regime: "neutral".into(),
            regime_changed: false,
            previous_regime: None,
            fsm_state: "Idle".into(),
            action: TickAction::None,
            triggered_rules: vec![],
        };

        logger.log_tick(&tick, None, None);

        let entries: Vec<_> = std::fs::read_dir(&test_dir)
            .unwrap()
            .filter_map(|e| e.ok())
            .collect();
        let content = std::fs::read_to_string(entries[0].path()).unwrap();
        let parsed: PlaybookTickLog = serde_json::from_str(content.trim()).unwrap();
        assert_eq!(parsed.unrealized_pnl, None);
        assert_eq!(parsed.entry_price, None);
        assert_eq!(parsed.current_price, None);

        let _ = std::fs::remove_dir_all(&test_dir);
    }
}