portfolio_analyzer/

portfolio.rs

/// Portfolio parsing: Fidelity All Accounts, Chase, Citi, Excel targets
use anyhow::Result;
use calamine::{open_workbook, Data, DataType, Reader, Xlsx};
use csv::ReaderBuilder;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// True junk: no meaningful value, never a real holding
pub const SKIP_SYMS: &[&str] = &["", "NAN", "82981P105", "SIRI"];

// Cash / money-market: real holdings, use CSV face value (NAV ≈ $1)
pub const CASH_SYMS: &[&str] = &[
    "SPAXX**",
    "FCASH**",
    "FDRXX**",
    "FDRXX",
    "FZBXX",
    "FSBXX",
    "FZDXX",
    "CORE**",
    "CASH_USD",
    "SPAXX",
    "CUSTODIAL_CASH", // Orion SMA fund custodial cash
];

pub const TAXABLE_NAMES: &[&str] = &[
    "TRUST: Suresh 1self managed",
    "TRUST: Suresh 2 self managed",
];

pub const NONTAXABLE_NAMES: &[&str] = &[
    "ROLLOVER IRA Suresh",
    "ROLLOVER IRA Check capital",
    "ROTH IRA- Suresh",
    "ROTH IRA Check capital",
    "ROLL OVER IRA  FISHER",
    "Orion TRADITIONAL IRA",
];

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Position {
    pub symbol: String,
    pub quantity: f64,
    pub value: f64,
    pub account: String,
    pub unrealized_gain: f64,
    pub cost_basis: f64,
}

fn clean_curr(s: &str) -> f64 {
    s.replace('$', "")
        .replace(',', "")
        .replace('+', "")
        .replace("--", "0")
        .replace('%', "")
        .trim()
        .parse::<f64>()
        .unwrap_or(0.0)
}

fn is_junk(sym: &str) -> bool {
    if sym.is_empty() {
        return true;
    }
    if SKIP_SYMS.contains(&sym) {
        return true;
    }
    // sym is already uppercased at call sites
    if sym.contains("BROKERAGE") || sym.contains("CUSIP") || sym.contains("PENDING") {
        return true;
    }
    false
}

// True for real equity (not cash/MM, not options, not junk).
// Use for weight/overlap computations and Yahoo Finance price fetching.
pub fn is_equity(sym: &str) -> bool {
    if is_junk(sym) {
        return false;
    }
    if CASH_SYMS.contains(&sym) {
        return false;
    }
    if sym.starts_with('-') {
        return false;
    } // options positions
    true
}

// ── Fidelity All Accounts CSV ─────────────────────────────────────────────────
pub fn parse_fidelity_all_accounts(path: &str) -> Result<Vec<Position>> {
    let mut rdr = ReaderBuilder::new().flexible(true).from_path(path)?;
    let headers = rdr.headers()?.clone();
    let h: Vec<&str> = headers.iter().collect();

    let find = |name: &str| -> Option<usize> {
        h.iter()
            .position(|&s| s.trim_start_matches('\u{feff}').trim() == name)
    };

    let acct_name_idx = find("Account Name").unwrap_or(1);
    let sym_idx = find("Symbol").unwrap_or(2);
    let qty_idx = find("Quantity").unwrap_or(4);
    let cv_idx = find("Current Value").unwrap_or(7);
    let gain_idx = find("Total Gain/Loss Dollar");
    let cost_idx = find("Cost Basis Total");

    let mut positions = Vec::new();
    for result in rdr.records() {
        let rec = match result {
            Ok(r) => r,
            Err(_) => continue,
        };
        let need = cv_idx.max(qty_idx).max(sym_idx).max(acct_name_idx);
        if rec.len() <= need {
            continue;
        }

        let acct_name = rec.get(acct_name_idx).unwrap_or("").trim().to_string();
        let sym = rec.get(sym_idx).unwrap_or("").trim().to_uppercase();

        if is_junk(&sym) {
            continue;
        }

        let is_taxable = TAXABLE_NAMES.iter().any(|&t| acct_name == t);
        let is_nontax = NONTAXABLE_NAMES.iter().any(|&t| acct_name == t);
        if !is_taxable && !is_nontax {
            continue;
        }

        let value = clean_curr(rec.get(cv_idx).unwrap_or("0"));
        let quantity = clean_curr(rec.get(qty_idx).unwrap_or("0"));
        let unrealized_gain = gain_idx
            .map(|i| clean_curr(rec.get(i).unwrap_or("0")))
            .unwrap_or(0.0);
        let cost_basis = cost_idx
            .map(|i| clean_curr(rec.get(i).unwrap_or("0")))
            .unwrap_or(0.0);
        if value <= 0.0 {
            continue;
        }

        positions.push(Position {
            symbol: sym,
            quantity,
            value,
            account: acct_name,
            unrealized_gain,
            cost_basis,
        });
    }
    Ok(positions)
}

// ── Chase CSV ─────────────────────────────────────────────────────────────────
pub fn parse_chase(path: &str) -> Result<Vec<Position>> {
    let mut rdr = ReaderBuilder::new().flexible(true).from_path(path)?;
    let headers = rdr.headers()?.clone();
    let h: Vec<&str> = headers.iter().collect();

    let ticker_idx = h.iter().position(|&s| s.trim() == "Ticker").unwrap_or(4);
    let qty_idx = h.iter().position(|&s| s.trim() == "Quantity").unwrap_or(6);
    let value_idx = h.iter().position(|&s| s.trim() == "Value").unwrap_or(15);
    let acct_idx = h
        .iter()
        .position(|&s| s.trim() == "Acct Type")
        .unwrap_or(61);
    let gain_idx = h.iter().position(|&s| s.trim() == "Unrealized G/L Amt.");
    let cost_idx = h.iter().position(|&s| s.trim() == "Cost");

    let mut out = Vec::new();
    for result in rdr.records() {
        let rec = match result {
            Ok(r) => r,
            Err(_) => continue,
        };
        if rec.get(acct_idx).unwrap_or("").trim() != "Cash" {
            continue;
        }
        let sym = rec.get(ticker_idx).unwrap_or("").trim().to_uppercase();
        if is_junk(&sym) {
            continue;
        }
        let value = clean_curr(rec.get(value_idx).unwrap_or("0"));
        let quantity = clean_curr(rec.get(qty_idx).unwrap_or("0"));
        let unrealized_gain = gain_idx
            .map(|i| clean_curr(rec.get(i).unwrap_or("0")))
            .unwrap_or(0.0);
        let cost_basis = cost_idx
            .map(|i| clean_curr(rec.get(i).unwrap_or("0")))
            .unwrap_or(0.0);
        if value <= 0.0 {
            continue;
        }
        out.push(Position {
            symbol: sym,
            quantity,
            value,
            account: "Chase Brokerage".to_string(),
            unrealized_gain,
            cost_basis,
        });
    }
    Ok(out)
}

// ── Citi CSV ──────────────────────────────────────────────────────────────────
pub fn parse_citi(path: &str) -> Result<Vec<Position>> {
    let content = std::fs::read_to_string(path)?;
    let lines: Vec<&str> = content.lines().collect();
    if lines.len() <= 10 {
        return Ok(vec![]);
    }

    let csv_part = lines[10..].join("\n");
    let mut rdr = ReaderBuilder::new()
        .flexible(true)
        .from_reader(csv_part.as_bytes());
    let headers = rdr.headers()?.clone();
    let h: Vec<&str> = headers.iter().collect();

    let sym_idx = h
        .iter()
        .position(|&s| s.trim() == "Security ID")
        .unwrap_or(1);
    let qty_idx = h.iter().position(|&s| s.trim() == "Quantity").unwrap_or(7);
    let mv_idx = h
        .iter()
        .position(|&s| s.trim() == "Market Value")
        .unwrap_or(13);
    let gain_idx = h.iter().position(|&s| s.trim() == "Gain/Loss $");

    let mut out = Vec::new();
    for result in rdr.records() {
        let rec = match result {
            Ok(r) => r,
            Err(_) => continue,
        };
        let sym = rec
            .get(sym_idx)
            .unwrap_or("")
            .replace(' ', "")
            .to_uppercase();
        if is_junk(&sym) {
            continue;
        }
        let value = clean_curr(rec.get(mv_idx).unwrap_or("0"));
        let quantity = clean_curr(rec.get(qty_idx).unwrap_or("0"));
        let unrealized_gain = gain_idx
            .map(|i| clean_curr(rec.get(i).unwrap_or("0")))
            .unwrap_or(0.0);
        let cost_basis = (value - unrealized_gain).max(0.0);
        if value <= 0.0 {
            continue;
        }
        out.push(Position {
            symbol: sym,
            quantity,
            value,
            account: "Citi Brokerage".to_string(),
            unrealized_gain,
            cost_basis,
        });
    }
    Ok(out)
}

// ── Excel target portfolios ───────────────────────────────────────────────────
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TargetPosition {
    pub symbol: String,
    pub weight: f64, // as fraction (0..1)
}

pub fn parse_excel_target(path: &str) -> Result<Vec<TargetPosition>> {
    let mut wb: Xlsx<_> = open_workbook(path)?;
    let sheet_name = wb
        .sheet_names()
        .first()
        .cloned()
        .ok_or_else(|| anyhow::anyhow!("no sheets"))?;
    let ws = wb
        .worksheet_range(&sheet_name)
        .map_err(|e| anyhow::anyhow!("range error: {e}"))?;

    let mut ticker_col = None;
    let mut weight_col = None;
    let mut data_start = 0usize;

    'outer: for (row_idx, row) in ws.rows().enumerate() {
        for (col_idx, cell) in row.iter().enumerate() {
            if let Data::String(s) = cell {
                let s = s.trim();
                if s == "Ticker" {
                    ticker_col = Some(col_idx);
                }
                if s == "Opt %" {
                    weight_col = Some(col_idx);
                }
            }
        }
        if ticker_col.is_some() && weight_col.is_some() {
            data_start = row_idx + 1;
            break 'outer;
        }
    }

    let tc = ticker_col.ok_or_else(|| anyhow::anyhow!("no Ticker column"))?;
    let wc = weight_col.ok_or_else(|| anyhow::anyhow!("no Opt % column"))?;

    let rows_vec: Vec<Vec<Data>> = ws.rows().skip(data_start).map(|r| r.to_vec()).collect();

    // Collect equity rows with raw weights first, then renormalise over kept rows only.
    // This ensures cash/junk rows excluded by is_equity() don't dilute the equity weights.
    let mut positions = Vec::new();
    for row in &rows_vec {
        let sym = match row.get(tc) {
            Some(Data::String(s)) => s.trim().to_uppercase(),
            _ => continue,
        };
        let w = match row.get(wc) {
            Some(c) => c.get_float().unwrap_or(0.0),
            None => continue,
        };
        if w <= 0.0 || !is_equity(&sym) {
            continue;
        }
        positions.push(TargetPosition {
            symbol: sym,
            weight: w,
        });
    }

    let kept_total: f64 = positions.iter().map(|p| p.weight).sum();
    if kept_total > 0.0 {
        for p in &mut positions {
            p.weight /= kept_total;
        }
    }
    Ok(positions)
}

// ── Aggregate positions ────────────────────────────────────────────────────────
pub fn aggregate(positions: &[Position]) -> HashMap<String, f64> {
    let mut map: HashMap<String, f64> = HashMap::new();
    for p in positions {
        *map.entry(p.symbol.clone()).or_insert(0.0) += p.value;
    }
    map
}

pub fn to_weights(agg: &HashMap<String, f64>) -> HashMap<String, f64> {
    let total: f64 = agg.values().sum();
    if total == 0.0 {
        return HashMap::new();
    }
    agg.iter().map(|(k, &v)| (k.clone(), v / total)).collect()
}

// ── Orion SMA fund CSV ────────────────────────────────────────────────────────
// Two formats supported:
//   Brinker:       Name, Ticker, Shares, Price, Market Value, Portfolio %
//   Capital Group: Company Name, Ticker, Shares/Quantity, Price, Total Value, Portfolio Weight
pub fn parse_orion_fund(path: &str, fund_name: &str) -> Result<Vec<Position>> {
    let mut rdr = ReaderBuilder::new().flexible(true).from_path(path)?;
    let headers = rdr.headers()?.clone();
    let h: Vec<&str> = headers.iter().collect();

    let ticker_idx = h.iter().position(|&s| s.trim() == "Ticker").unwrap_or(1);
    let qty_idx = h
        .iter()
        .position(|&s| {
            let t = s.trim();
            t == "Shares" || t == "Shares/Quantity"
        })
        .unwrap_or(2);
    let val_idx = h
        .iter()
        .position(|&s| {
            let t = s.trim();
            t == "Market Value" || t == "Total Value"
        })
        .unwrap_or(4);

    let mut out = Vec::new();
    for result in rdr.records() {
        let rec = match result {
            Ok(r) => r,
            Err(_) => continue,
        };
        let raw_sym = rec.get(ticker_idx).unwrap_or("").trim().to_uppercase();
        if raw_sym.is_empty() {
            continue;
        } // total row

        let value = clean_curr(rec.get(val_idx).unwrap_or("0"));
        let quantity = clean_curr(rec.get(qty_idx).unwrap_or("0"));
        if value <= 0.0 {
            continue;
        }

        // CUSTODIAL_CASH is in CASH_SYMS → is_equity returns false, included at face value
        // Other junk skipped
        if raw_sym != "CUSTODIAL_CASH" && is_junk(&raw_sym) {
            continue;
        }

        out.push(Position {
            symbol: raw_sym,
            quantity,
            value,
            account: fund_name.to_string(),
            unrealized_gain: 0.0,
            cost_basis: 0.0,
        });
    }
    Ok(out)
}