All-in-one-Financial-Analysis/app.py

"""
All-in-One Financial Analysis Dashboard — Hybrid Architecture
- Tab 1: 10-K & MD&A Insights (Item 7 + Item 1A → Gemini, qualitative only).
- Tab 2: 3-Scenario DCF Valuation (yfinance + sliders, no LLM).
- Tab 3: Industry Comps (yfinance multiples: Forward P/E, EV/EBITDA, P/B).
- Cost-effective: Gemini only for text; all numbers from yfinance.
"""

import json
import os
import re
import tempfile
import threading
import time
from pathlib import Path
from typing import Optional, Any


# Local prefs file for "Remember me" (API key & email). Path is in .gitignore.
_PREFS_PATH = Path(__file__).resolve().parent / ".app_prefs.json"
# Persistent 10-K cache: data/ticker_latest.json (Item 1A, 3, 7, 9A cleaned text).
_DATA_DIR = Path(__file__).resolve().parent / "data"


def _load_prefs() -> dict:
    """Load saved API keys and email from local file. Keys: google_api_key, sec_email."""
    try:
        if _PREFS_PATH.exists():
            with open(_PREFS_PATH, "r", encoding="utf-8") as f:
                return json.load(f)
    except Exception:
        pass
    return {}


def _save_prefs(google_api_key: str, sec_email: str) -> None:
    """Save API keys and email to local file (only if user opted in)."""
    try:
        data = {
            "google_api_key": (google_api_key or "").strip(),
            "sec_email": (sec_email or "").strip(),
        }
        with open(_PREFS_PATH, "w", encoding="utf-8") as f:
            json.dump(data, f, indent=2)
    except Exception:
        pass

import streamlit as st
import pandas as pd
from bs4 import BeautifulSoup

try:
    import plotly.express as px
    import plotly.graph_objects as go
except ImportError:
    px = None
    go = None

try:
    from dotenv import load_dotenv
    load_dotenv()
except ImportError:
    pass

try:
    import yfinance as yf
except ImportError:
    yf = None

try:
    from yahooquery import Ticker as YQTicker
    from yahooquery import search as yq_search
except ImportError:
    YQTicker = None
    yq_search = None

# Company name → ticker for search/autocomplete (expand as needed)
COMPANY_LIST = [
    ("NVIDIA Corporation", "NVDA"), ("Apple Inc.", "AAPL"), ("Microsoft Corporation", "MSFT"),
    ("Amazon.com Inc.", "AMZN"), ("Alphabet Inc.", "GOOGL"), ("Meta Platforms Inc.", "META"),
    ("AMD", "AMD"), ("Intel Corporation", "INTC"), ("Qualcomm Inc.", "QCOM"), ("Tesla Inc.", "TSLA"),
    ("Berkshire Hathaway", "BRK.B"), ("JPMorgan Chase", "JPM"), ("Visa Inc.", "V"), ("UnitedHealth", "UNH"),
    ("Procter & Gamble", "PG"), ("Exxon Mobil", "XOM"), ("Johnson & Johnson", "JNJ"), ("Mastercard", "MA"),
    ("Chevron", "CVX"), ("Home Depot", "HD"), ("Merck", "MRK"), ("AbbVie", "ABBV"), ("Costco", "COST"),
    ("PepsiCo", "PEP"), ("Coca-Cola", "KO"), ("Pfizer", "PFE"), ("Walmart", "WMT"), ("Netflix", "NFLX"),
    ("Adobe", "ADBE"), ("Salesforce", "CRM"), ("Comcast", "CMCSA"), ("Cisco", "CSCO"), ("Oracle", "ORCL"),
    ("American Express", "AXP"), ("Bank of America", "BAC"), ("Wells Fargo", "WFC"), ("Verizon", "VZ"),
    ("AT&T", "T"), ("Walt Disney", "DIS"), ("Nike", "NKE"), ("McDonald's", "MCD"), ("Starbucks", "SBUX"),
    ("Goldman Sachs", "GS"), ("Morgan Stanley", "MS"), ("Target", "TGT"), ("Boeing", "BA"), ("IBM", "IBM"),
]
COMPANY_OPTIONS = [f"{t} - {n}" for n, t in COMPANY_LIST]
COMPANY_TICKER_MAP = {t: n for n, t in COMPANY_LIST}

MARKET_OPTIONS = [
    "US (S&P/Dow/Nasdaq)",
    "South Korea (KOSPI/KOSDAQ)",
    "Japan (Nikkei)",
    "UK (LSE)",
]


def get_global_ticker(ticker: str, market: str) -> str:
    """Format ticker for Yahoo Finance by market. US: as-is. South Korea: .KS or .KQ. Japan: .T. UK: .L. If ticker already has suffix, return as-is."""
    if not (ticker or "").strip():
        return (ticker or "").strip()
    t = (ticker or "").strip()
    if t.upper().endswith((".KS", ".KQ", ".T", ".L")):
        return t
    m = (market or "").strip()
    if "US" in m or not m:
        return t
    if "Korea" in m or "KOSPI" in m or "KOSDAQ" in m:
        return t + ".KS"
    if "Japan" in m or "Nikkei" in m:
        return t + ".T"
    if "UK" in m or "LSE" in m:
        return t + ".L"
    return t


def infer_market_from_ticker(ticker: str) -> str:
    """Infer market label from ticker suffix (for Deep-Dive routing when no Market selector)."""
    if not (ticker or "").strip():
        return MARKET_OPTIONS[0]
    t = (ticker or "").strip().upper()
    if t.endswith(".KS") or t.endswith(".KQ"):
        return "South Korea (KOSPI/KOSDAQ)"
    if t.endswith(".T"):
        return "Japan (Nikkei)"
    if t.endswith(".L"):
        return "UK (LSE)"
    return "US (S&P/Dow/Nasdaq)"


# Top-down sector analysis: industry → top 5 S&P 500 / NASDAQ tickers
SECTORS = {
    "Semiconductors & Hardware": ["NVDA", "AMD", "INTC", "TSM", "AVGO"],
    "Software & Cloud": ["MSFT", "ADBE", "CRM", "PANW", "CRWD"],
    "Consumer Retail": ["AMZN", "SBUX", "MCD", "WMT", "HD"],
    "Financial Services": ["JPM", "BAC", "GS", "MS", "V"],
    "Healthcare": ["LLY", "UNH", "JNJ", "ABBV", "MRK"],
}


def get_edgar_downloader():
    from sec_edgar_downloader import Downloader
    return Downloader


def _slice_html_items_1a_to_9a(raw_html: str) -> str:
    """Fast string slice: keep only Item 1A through end of Item 9A to avoid parsing 50MB+ full file. Uses .find()/regex on raw string only."""
    if not raw_html or len(raw_html) < 5000:
        return raw_html
    start = -1
    for needle in ("Item 1A", "ITEM 1A", "Item 1a"):
        i = raw_html.find(needle)
        if i != -1 and (start == -1 or i < start):
            start = i
    if start == -1:
        m = re.search(r"Item\s+1A\s", raw_html, re.IGNORECASE)
        start = m.start() if m else 0
    else:
        start = max(0, start - 200)
    search_region = raw_html[start:]
    end_match = re.search(r"Item\s+10\s|Item\s+12\s|Part\s+III\b|PART\s+III\b", search_region, re.IGNORECASE)
    end = start + end_match.start() if end_match else len(raw_html)
    end = min(end, start + 8_000_000)
    return raw_html[start:end]


def _extract_text_from_html_string(html_str: str) -> str:
    """Parse HTML string with lxml; drop table/img/svg/style/script immediately to reduce memory and speed."""
    if not html_str or not html_str.strip():
        return ""
    try:
        soup = BeautifulSoup(html_str, "lxml")
    except Exception:
        soup = BeautifulSoup(html_str, "html.parser")
    for tag in soup.find_all(["table", "img", "svg", "style", "script"]):
        tag.decompose()
    return soup.get_text(separator="\n", strip=True)


def extract_text_from_html(html_path: Path) -> str:
    try:
        with open(html_path, "r", encoding="utf-8", errors="replace") as f:
            raw = f.read()
    except Exception:
        with open(html_path, "r", encoding="latin-1", errors="replace") as f:
            raw = f.read()
    chunk = _slice_html_items_1a_to_9a(raw)
    return _extract_text_from_html_string(chunk)


def extract_text_from_file(file_path: Path) -> str:
    suf = file_path.suffix.lower()
    if suf in (".htm", ".html"):
        return extract_text_from_html(file_path)
    if suf == ".txt":
        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
            text = f.read()
        text = re.sub(r"<[^>]+>", " ", text)
        text = re.sub(r"\s+", " ", text)
        return text
    return ""


# Section patterns for 10-K items
ITEM1A_PATTERNS = [
    r"Item\s+1A\s*[.:]\s*Risk\s+Factors",
    r"ITEM\s+1A\s*[.:]\s*Risk\s+Factors",
]
ITEM7_PATTERNS = [
    r"Item\s+7\s*[.:]\s*Management['\u2019]s\s+Discussion\s+and\s+Analysis",
    r"ITEM\s+7\s*[.:]\s*Management['\u2019]s\s+Discussion",
    r"Item\s+7\s*[.:]\s*[\w\s]+MD&A",
]
ITEM8_PATTERNS = [
    r"Item\s+8\s*[.:]\s*Financial\s+Statements",
    r"ITEM\s+8\s*[.:]\s*Financial\s+Statements",
]
ITEM3_PATTERNS = [
    r"Item\s+3\s*[.:]\s*Legal\s+Proceedings",
    r"ITEM\s+3\s*[.:]\s*Legal\s+Proceedings",
]
ITEM9A_PATTERNS = [
    r"Item\s+9A\s*[.:]\s*Controls\s+and\s+Procedures",
    r"Item\s+9A\s*[.:]\s*Internal\s+Control",
    r"ITEM\s+9A\s*[.:]\s*Controls",
]


def _find_section_start(text: str, patterns: list, item_num: int) -> int:
    for pat in patterns:
        m = re.search(pat, text, re.IGNORECASE)
        if m:
            return m.start()
    m = re.search(r"\bItem\s+" + str(item_num) + r"\b", text, re.IGNORECASE)
    return m.start() if m else -1


def find_item_section_generic(text: str, patterns: list, item_num: int, title_keywords: list, max_chars: int = 120000) -> str:
    start = _find_section_start(text, patterns, item_num)
    if start == -1:
        pattern = re.compile(
            r"\bItem\s+" + str(item_num) + r"\b[.\s]*[^\n]*(" + "|".join(re.escape(k) for k in title_keywords) + r")?",
            re.IGNORECASE,
        )
        match = pattern.search(text)
        if not match:
            return ""
        start = match.start()
    next_item = re.search(r"\n\s*Item\s+\d+[A-Z]?\s+", text[start + 100:], re.IGNORECASE)
    if next_item:
        end = start + 100 + next_item.start()
    else:
        end = min(start + max_chars, len(text))
    return text[start:end].strip()


def clean_text_for_llm(html_content: str) -> str:
    """Aggressive cleaning for LLM: strip tables/code, collapse whitespace, drop non-ASCII. Uses lxml for speed; drops table/img/svg/style/script."""
    if not html_content or not html_content.strip():
        return ""
    try:
        soup = BeautifulSoup(html_content, "lxml")
        for tag in soup.find_all(["table", "img", "style", "script", "svg", "math"]):
            tag.decompose()
        text = soup.get_text(separator=" ")
    except Exception:
        text = re.sub(r"<[^>]+>", " ", html_content)
    text = re.sub(r"\s+", " ", text)
    text = " ".join(text.split())
    text = re.sub(r"[^\x20-\x7E\n]", " ", text)
    text = re.sub(r"\s+", " ", text).strip()
    lines = []
    for line in text.split("\n"):
        line = line.strip()
        if not line:
            continue
        if re.fullmatch(r"\d+", line) or re.fullmatch(r"[\.\-\s\-]+", line):
            continue
        if re.match(r"^(page\s+\d+|\d+)\s*$", line, re.IGNORECASE) and len(line) < 20:
            continue
        lines.append(line)
    result = " ".join(lines)
    result = re.sub(r"\s+", " ", result).strip()
    return result


def smart_chunk(section: str, max_chars: int = 10000, head_ratio: float = 0.5) -> str:
    """Limit payload for Gemini; 10k chars ≈ 2.5k tokens for fast response."""
    if not section or len(section) <= max_chars:
        return section
    head_size = int(max_chars * head_ratio)
    tail_size = max_chars - head_size - 100
    return section[:head_size] + " [ ... middle omitted ... ] " + section[-tail_size:]


def find_downloaded_10k_path(download_root: Path, ticker: str) -> Optional[Path]:
    ticker_upper = ticker.upper()
    for base in (download_root / "sec-edgar-filings", download_root):
        path_10k = base / ticker_upper / "10-K"
        if path_10k.exists():
            subdirs = sorted([d for d in path_10k.iterdir() if d.is_dir()], key=lambda x: x.name, reverse=True)
            if subdirs:
                return subdirs[0]
    for base in (download_root / "sec-edgar-filings", download_root):
        if not base.exists():
            continue
        for company_dir in base.iterdir():
            if not company_dir.is_dir():
                continue
            path_10k = company_dir / "10-K"
            if path_10k.exists():
                subdirs = sorted([d for d in path_10k.iterdir() if d.is_dir()], key=lambda x: x.name, reverse=True)
                if subdirs:
                    return subdirs[0]
    return None


def find_all_10k_filing_dirs(download_root: Path, ticker: str) -> list:
    """Return list of 10-K filing dirs sorted newest first (for multi-year comparison)."""
    ticker_upper = ticker.upper()
    for base in (download_root / "sec-edgar-filings", download_root):
        path_10k = base / ticker_upper / "10-K"
        if path_10k.exists():
            subdirs = sorted([d for d in path_10k.iterdir() if d.is_dir()], key=lambda x: x.name, reverse=True)
            return subdirs
    return []


def get_main_10k_text(filing_dir: Path) -> str:
    all_text = []
    for ext in ("*.htm", "*.html", "*.txt"):
        for path in filing_dir.rglob(ext):
            try:
                t = extract_text_from_file(path)
                if len(t) > 1000:
                    all_text.append((path, t))
            except Exception:
                continue
    if not all_text:
        return ""
    _, main_text = max(all_text, key=lambda x: len(x[1]))
    return main_text


def _get_10k_cache_path(ticker: str) -> Path:
    """Path for cached 10-K sections: data/TICKER_latest.json."""
    _DATA_DIR.mkdir(parents=True, exist_ok=True)
    return _DATA_DIR / f"{ticker.upper()}_latest.json"


def _load_10k_from_cache(ticker: str) -> Optional[dict]:
    """Load Item 1A, 3, 7, 8, 9A (plain text) from data/ticker_latest.json. Returns None if missing. When present, no re-download or re-parse."""
    path = _get_10k_cache_path(ticker)
    if not path.exists():
        return None
    try:
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    except Exception:
        return None


def _save_10k_to_cache(ticker: str, data: dict) -> None:
    """Save cleaned 10-K sections to data/ticker_latest.json."""
    path = _get_10k_cache_path(ticker)
    _DATA_DIR.mkdir(parents=True, exist_ok=True)
    with open(path, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=0)


def _extract_item_from_full(text: str, patterns: list, item_num: int, keywords: list, max_chars: int = 60000) -> str:
    """Extract one item section from full 10-K text."""
    start = _find_section_start(text, patterns, item_num)
    if start < 0:
        pattern = re.compile(r"\bItem\s+" + str(item_num) + r"[A-Z]?\b[.\s]*[^\n]*", re.IGNORECASE)
        match = pattern.search(text)
        start = match.start() if match else -1
    if start < 0:
        return ""
    next_item = re.search(r"\n\s*Item\s+\d+[A-Z]?\s+", text[start + 100:], re.IGNORECASE)
    end = start + 100 + next_item.start() if next_item else min(start + max_chars, len(text))
    return text[start:end].strip()


def download_and_extract_all_items(ticker: str, email: str) -> dict:
    """Download latest 10-K, extract Item 1A, 3, 7, 9A; clean and return (and optionally cache)."""
    Downloader = get_edgar_downloader()
    with tempfile.TemporaryDirectory() as tmpdir:
        download_root = Path(tmpdir)
        dl = Downloader("FQDC-10K-Analyzer", email, str(download_root))
        dl.get("10-K", ticker.upper(), limit=1, download_details=True)
        filing_dir = find_downloaded_10k_path(download_root, ticker)
        if not filing_dir:
            raise FileNotFoundError(f"Could not find 10-K for ticker '{ticker}'.")
        full_text = get_main_10k_text(filing_dir)
        if not full_text:
            raise ValueError("Could not extract text from the 10-K.")
    item1a = find_item_section_generic(full_text, ITEM1A_PATTERNS, 1, ["Risk", "Factors"], max_chars=80000)
    item3 = _extract_item_from_full(full_text, ITEM3_PATTERNS, 3, ["Legal", "Proceedings"], max_chars=40000)
    item9a = _extract_item_from_full(full_text, ITEM9A_PATTERNS, 9, ["Controls", "Procedures", "Internal"], max_chars=40000)
    start7 = _find_section_start(full_text, ITEM7_PATTERNS, 7)
    text_after_7 = full_text[start7:] if start7 >= 0 else full_text
    item7 = find_item_section_generic(text_after_7, ITEM7_PATTERNS, 7, ["Management's Discussion", "MD&A", "Analysis"], max_chars=100000)
    if not item7 and text_after_7:
        item7 = text_after_7[:120000]
    item8 = _extract_item_from_full(full_text, ITEM8_PATTERNS, 8, ["Financial Statements", "Supplementary Data"], max_chars=200000)
    data = {
        "item1a": clean_text_for_llm(item1a or ""),
        "item3": clean_text_for_llm(item3 or ""),
        "item9a": clean_text_for_llm(item9a or ""),
        "item7": clean_text_for_llm(item7 or ""),
        "item8": clean_text_for_llm(item8 or ""),
    }
    _save_10k_to_cache(ticker, data)
    return data


def get_10k_sections(ticker: str, email: str) -> tuple[dict, str]:
    """Return (sections dict, status). status = 'cache' if loaded from file else 'downloaded'. Cached ticker skips download and parsing entirely (item1a, item3, item7, item8, item9a)."""
    cached = _load_10k_from_cache(ticker)
    if cached is not None:
        return cached, "cache"
    return download_and_extract_all_items(ticker, email), "downloaded"


def download_and_extract_item7_and_1a(ticker: str, email: str) -> tuple[str, str, str]:
    """Fetch 10-K from SEC EDGAR and return full_text, Item 1A (Risk Factors), Item 7 (MD&A). Uses cache when available."""
    sections, _ = get_10k_sections(ticker, email)
    return "", sections.get("item1a", "") or "", sections.get("item7", "") or ""


def download_item7_latest_and_3y_ago(ticker: str, email: str) -> tuple[Optional[str], Optional[str], Optional[str], bool]:
    """Download up to 5 10-Ks; extract Item 1A (latest only) and Item 7 from latest and from 3 years ago.
    Returns (item1a_latest, item7_latest, item7_3y_ago, has_comparison). If < 4 filings, item7_3y_ago is None."""
    Downloader = get_edgar_downloader()
    with tempfile.TemporaryDirectory() as tmpdir:
        download_root = Path(tmpdir)
        dl = Downloader("FQDC-10K-Analyzer", email, str(download_root))
        dl.get("10-K", ticker.upper(), limit=5, download_details=True)
        filing_dirs = find_all_10k_filing_dirs(download_root, ticker)
        if not filing_dirs:
            raise FileNotFoundError(f"Could not find 10-K for ticker '{ticker}'.")
        full_latest = get_main_10k_text(filing_dirs[0])
        if not full_latest:
            raise ValueError("Could not extract text from the latest 10-K.")
        item1a = find_item_section_generic(
            full_latest, ITEM1A_PATTERNS, 1, ["Risk", "Factors"], max_chars=80000
        )
        text_after_7 = full_latest[_find_section_start(full_latest, ITEM7_PATTERNS, 7):] if _find_section_start(full_latest, ITEM7_PATTERNS, 7) >= 0 else full_latest
        item7_latest = find_item_section_generic(
            text_after_7, ITEM7_PATTERNS, 7, ["Management's Discussion", "MD&A", "Analysis"], max_chars=100000
        )
        if not item7_latest and text_after_7:
            item7_latest = smart_chunk(text_after_7[:120000], max_chars=20000)
        item7_3y_ago = None
        has_comparison = False
        if len(filing_dirs) >= 4:
            full_3y = get_main_10k_text(filing_dirs[3])
            if full_3y:
                text_3y = full_3y[_find_section_start(full_3y, ITEM7_PATTERNS, 7):] if _find_section_start(full_3y, ITEM7_PATTERNS, 7) >= 0 else full_3y
                item7_3y_ago = find_item_section_generic(
                    text_3y, ITEM7_PATTERNS, 7, ["Management's Discussion", "MD&A", "Analysis"], max_chars=100000
                )
                if not item7_3y_ago and text_3y:
                    item7_3y_ago = smart_chunk(text_3y[:120000], max_chars=20000)
                has_comparison = bool(item7_3y_ago)
    return item1a or "", item7_latest or "", item7_3y_ago, has_comparison


# ---------- Gemini (qualitative only) ----------
GEMINI_MODEL = "gemini-2.0-flash"
RATE_LIMIT_WAIT_SEC = 60


def get_gemini_model(api_key: str):
    import google.generativeai as genai
    genai.configure(api_key=api_key)
    return genai.GenerativeModel(GEMINI_MODEL)


def _is_rate_limit_error(e: Exception) -> bool:
    err_msg = str(e).lower()
    return "429" in err_msg or "resourcelimited" in err_msg or "resource exhausted" in err_msg or getattr(e, "code", None) == 429


def _generate_with_retry(model, content, config, max_retries: int = 3):
    last_err = None
    for attempt in range(max_retries + 1):
        try:
            return model.generate_content(content, generation_config=config)
        except Exception as e:
            last_err = e
            if attempt < max_retries and _is_rate_limit_error(e):
                time.sleep(RATE_LIMIT_WAIT_SEC)
                continue
            raise
    raise last_err


def _generate_stream(model, content, config):
    """Yield text chunks from Gemini with stream=True. For use with st.write_stream()."""
    try:
        response = model.generate_content(content, generation_config=config, stream=True)
        for chunk in response:
            if hasattr(chunk, "text") and chunk.text:
                yield chunk.text
    except Exception:
        raise


def _split_into_chunks(text: str, max_chars: int = 22000, min_chunk: int = 5000) -> list:
    """Split text into sequential chunks without cutting mid-sentence when possible."""
    if not text or len(text) <= max_chars:
        return [text] if text and text.strip() else []
    chunks = []
    start = 0
    while start < len(text):
        end = min(start + max_chars, len(text))
        if end < len(text):
            break_at = text.rfind("\n\n", start, end + 1)
            if break_at > start + min_chunk:
                end = break_at + 2
        chunks.append(text[start:end].strip())
        start = end
    return [c for c in chunks if c]


def _gemini_summarize_segment(api_key: str, segment_text: str, ticker: str, segment_label: str) -> str:
    """Extract strategic shifts and hidden risks from one segment. No trimming."""
    model = get_gemini_model(api_key)
    prompt = f"""You are a senior equity analyst. The following is one segment of the 10-K for {ticker} (Item 1A Risk Factors and/or Item 7 MD&A).
Extract and list all significant: (1) strategic shifts or priorities, (2) hidden or material risks, (3) management tone cues. Use concise bullet points. Do not omit important details. Segment: {segment_label}."""
    full = f"""--- 10-K Segment ---\n\n{segment_text[:50000]}\n\n---\n\n{prompt}"""
    try:
        r = _generate_with_retry(model, full, {"temperature": 0.2, "max_output_tokens": 2048})
        return (r.text or "").strip()
    except Exception:
        return ""


def _gemini_synthesize_report(api_key: str, segment_summaries: list, ticker: str, sector: str, industry: str) -> str:
    """Synthesis call: turn segment summaries into Executive Insight Report."""
    model = get_gemini_model(api_key)
    combined = "\n\n---\n\n".join(segment_summaries)
    kpi_note = f" Sector: {sector}; Industry: {industry}. Include industry-specific KPIs if mentioned." if sector and sector != "N/A" else ""
    prompt = f"""You are a senior equity analyst. Use British English. Below are summarized insights from the full 10-K for {ticker} (Item 1A and Item 7). Create the final **Executive Insight Report** with these sections:

1. **Management's Tone (Sentiment)**: Overall tone and supporting evidence.
2. **Current Strategy & Priorities**: Key strategic focus, capital allocation, growth drivers.
3. **Major Hidden Risks**: The 3–4 most material risks investors might overlook.
4. **Forensic / Quality of Earnings**: Accounting caveats, one-offs, cash flow vs earnings. If none material, say so briefly.{kpi_note}

Use clear headings. Do not invent figures. Keep under 900 words."""
    full = f"""--- Segment Summaries ---\n\n{combined}\n\n---\n\n{prompt}"""
    try:
        r = _generate_with_retry(model, full, {"temperature": 0.3, "max_output_tokens": 4096})
        return (r.text or "").strip()
    except Exception:
        return ""


def _gemini_forensic_audit(api_key: str, item3: str, item9a: str, ticker: str) -> str:
    """Dedicated high-priority check: Material Weaknesses, lawsuits, off-balance-sheet from Item 3 and 9A."""
    model = get_gemini_model(api_key)
    combined = (item3 or "") + "\n\n---\n\n" + (item9a or "")
    if not combined.strip():
        return "✅ No Item 3 / 9A text provided; skip forensic."
    prompt = f"""From the following 10-K excerpts for {ticker} (Item 3 Legal Proceedings and Item 9A Controls/Internal Control), list any:
- Material weaknesses in internal control
- Significant legal proceedings or litigation
- Off-balance-sheet or governance red flags
If none of the above, output exactly: "✅ No material red flags or special issues detected in Item 3 and 9A."
Be concise (under 150 words)."""
    full = f"""--- Item 3 & 9A ---\n\n{combined[:30000]}\n\n---\n\n{prompt}"""
    try:
        r = _generate_with_retry(model, full, {"temperature": 0.1, "max_output_tokens": 512})
        return (r.text or "").strip()
    except Exception:
        return ""


_REQUIRED_FINANCIAL_KEYS = [
    "Revenue", "CostOfRevenue", "OperatingExpenses", "NetIncome",
    "TotalAssets", "CurrentAssets", "CurrentLiabilities", "LongTermDebt",
    "OperatingCashFlow", "SharesOutstanding",
]


@st.cache_data(ttl=3600)
def get_sec_financials_llm(api_key: str, item8_text: str, ticker: str) -> dict:
    """Extract Current Year and Previous Year financial figures from 10-K Item 8 via Gemini. Returns dict with current_yr and previous_yr (each with 10 numeric fields). Cached by (api_key, item8_text, ticker)."""
    if not (api_key or "").strip() or not (item8_text or "").strip():
        return {}
    payload = smart_chunk((item8_text or "").strip(), max_chars=35000)
    model = get_gemini_model(api_key)
    prompt = f"""You are a financial analyst. Below is Item 8 (Financial Statements and Supplementary Data) from the latest 10-K for {ticker}.

Extract the following figures for the **Current Year** (most recent fiscal year) and **Previous Year** (prior fiscal year). Use the exact numbers from the financial statements. All monetary values in millions (e.g. 50000 for $50 billion). Shares in millions.

Return ONLY a valid JSON object, no other text. Use this exact structure:
{{
  "current_yr": {{
    "Revenue": <number>,
    "CostOfRevenue": <number>,
    "OperatingExpenses": <number>,
    "NetIncome": <number>,
    "TotalAssets": <number>,
    "CurrentAssets": <number>,
    "CurrentLiabilities": <number>,
    "LongTermDebt": <number>,
    "OperatingCashFlow": <number>,
    "SharesOutstanding": <number>
  }},
  "previous_yr": {{
    "Revenue": <number>,
    "CostOfRevenue": <number>,
    "OperatingExpenses": <number>,
    "NetIncome": <number>,
    "TotalAssets": <number>,
    "CurrentAssets": <number>,
    "CurrentLiabilities": <number>,
    "LongTermDebt": <number>,
    "OperatingCashFlow": <number>,
    "SharesOutstanding": <number>
  }}
}}

If a value is not found in the document, use 0 or a reasonable estimate and still include the key. Output nothing except this JSON."""

    full = f"""--- Item 8 (Financial Statements) ---\n\n{payload}\n\n---\n\n{prompt}"""
    try:
        r = _generate_with_retry(model, full, {"temperature": 0.0, "max_output_tokens": 2048})
        raw = (r.text or "").strip()
        if not raw:
            return {}
        raw = re.sub(r"^```\s*json\s*", "", raw)
        raw = re.sub(r"^```\s*", "", raw)
        raw = re.sub(r"\s*```\s*$", "", raw)
        raw = raw.strip()
        out = json.loads(raw)
        cur = out.get("current_yr") or {}
        prev = out.get("previous_yr") or {}
        for key in _REQUIRED_FINANCIAL_KEYS:
            cur[key] = _safe_float(cur.get(key)) or 0
            prev[key] = _safe_float(prev.get(key)) or 0
        return {"current_yr": cur, "previous_yr": prev}
    except (json.JSONDecodeError, Exception):
        return {}


def get_gemini_item7_strategy(api_key: str, item7_text: str, ticker: str, sector: str, industry: str) -> str:
    """Item 7 only: business performance, strategic shifts, capital allocation."""
    if not (item7_text or "").strip():
        return "No Item 7 (MD&A) text available."
    model = get_gemini_model(api_key)
    text = smart_chunk(clean_text_for_llm(item7_text), max_chars=10000)
    sector_note = f" Sector: {sector}; Industry: {industry}." if sector and sector != "N/A" else ""
    prompt = f"""You are a senior equity analyst. Use British English. The text below is **Item 7 (Management's Discussion and Analysis)** from the latest 10-K for {ticker}.{sector_note}

Provide a concise **Management Strategy** report with these sections:

1. **Business performance**: Key revenue, margin, or segment highlights management emphasises.
2. **Strategic shifts**: Changes in priorities, growth drivers, or capital allocation (e.g. capex, M&A, buybacks).
3. **Capital allocation**: How management describes use of cash (dividends, debt paydown, R&D, acquisitions).

Use clear headings. Do not invent figures. Keep under 600 words. Focus only on narrative insights; ignore missing quantitative data.
Even if the source text is in another language (e.g. Korean or Japanese), analyse it and output your final report strictly in British English."""
    full = f"""--- Item 7 (MD&A) ---\n\n{text}\n\n---\n\n{prompt}"""
    try:
        r = _generate_with_retry(model, full, {"temperature": 0.3, "max_output_tokens": 2048})
        return (r.text or "").strip()
    except Exception:
        return ""


def get_gemini_item7_strategy_stream(api_key: str, item7_text: str, ticker: str, sector: str, industry: str):
    """Generator that yields MD&A strategy report chunks for real-time streaming (e.g. st.write_stream)."""
    if not (item7_text or "").strip():
        yield "No Item 7 (MD&A) text available."
        return
    model = get_gemini_model(api_key)
    text = smart_chunk(clean_text_for_llm(item7_text), max_chars=10000)
    sector_note = f" Sector: {sector}; Industry: {industry}." if sector and sector != "N/A" else ""
    prompt = f"""You are a senior equity analyst. Use British English. The text below is **Item 7 (Management's Discussion and Analysis)** from the latest 10-K for {ticker}.{sector_note}

Provide a concise **Management Strategy** report with these sections:

1. **Business performance**: Key revenue, margin, or segment highlights management emphasises.
2. **Strategic shifts**: Changes in priorities, growth drivers, or capital allocation (e.g. capex, M&A, buybacks).
3. **Capital allocation**: How management describes use of cash (dividends, debt paydown, R&D, acquisitions).

Use clear headings. Do not invent figures. Keep under 600 words. Focus only on narrative insights; ignore missing quantitative data.
Even if the source text is in another language (e.g. Korean or Japanese), analyse it and output your final report strictly in British English."""
    full = f"""--- Item 7 (MD&A) ---\n\n{text}\n\n---\n\n{prompt}"""
    config = {"temperature": 0.3, "max_output_tokens": 2048}
    yield from _generate_stream(model, full, config)


def get_gemini_item1a_risks(api_key: str, item1a_text: str, item3: str, item9a: str, ticker: str) -> str:
    """Item 1A only: legal, operational, market-related threats. Includes Forensic Audit (Item 3 & 9A) as safety check."""
    if not (item1a_text or "").strip():
        return "No Item 1A (Risk Factors) text available."
    model = get_gemini_model(api_key)
    text = smart_chunk(clean_text_for_llm(item1a_text), max_chars=10000)
    prompt = f"""You are a senior equity analyst. Use British English. The text below is **Item 1A (Risk Factors)** from the latest 10-K for {ticker}.

Provide a concise **Risk Factors** report with these sections:

1. **Legal & regulatory risks**: Litigation, regulatory changes, compliance.
2. **Operational risks**: Supply chain, key person, technology, execution.
3. **Market & competitive risks**: Demand, competition, macro, currency.

Use clear headings. Do not invent figures. Keep under 500 words. Focus only on narrative insights; ignore missing quantitative data.
Even if the source text is in another language (e.g. Korean or Japanese), analyse it and output your final report strictly in British English."""
    full = f"""--- Item 1A (Risk Factors) ---\n\n{text}\n\n---\n\n{prompt}"""
    try:
        report = _generate_with_retry(model, full, {"temperature": 0.3, "max_output_tokens": 2048})
        risks = (report.text or "").strip()
    except Exception:
        risks = ""
    forensic = _gemini_forensic_audit(api_key, item3 or "", item9a or "", ticker)
    return (risks or "") + "\n\n---\n\n**Forensic Audit (Item 3 & 9A)**\n\n" + (forensic or "")


def get_gemini_item1a_risks_stream(api_key: str, item1a_text: str, ticker: str):
    """Generator that yields Risk Factors report chunks for real-time streaming. Caller appends Forensic (Item 3 & 9A) after stream."""
    if not (item1a_text or "").strip():
        yield "No Item 1A (Risk Factors) text available."
        return
    model = get_gemini_model(api_key)
    text = smart_chunk(clean_text_for_llm(item1a_text), max_chars=10000)
    prompt = f"""You are a senior equity analyst. Use British English. The text below is **Item 1A (Risk Factors)** from the latest 10-K for {ticker}.

Provide a concise **Risk Factors** report with these sections:

1. **Legal & regulatory risks**: Litigation, regulatory changes, compliance.
2. **Operational risks**: Supply chain, key person, technology, execution.
3. **Market & competitive risks**: Demand, competition, macro, currency.

Use clear headings. Do not invent figures. Keep under 500 words. Focus only on narrative insights; ignore missing quantitative data.
Even if the source text is in another language (e.g. Korean or Japanese), analyse it and output your final report strictly in British English."""
    full = f"""--- Item 1A (Risk Factors) ---\n\n{text}\n\n---\n\n{prompt}"""
    config = {"temperature": 0.3, "max_output_tokens": 2048}
    yield from _generate_stream(model, full, config)


def get_mda_chunked_insights(
    api_key: str, sections: dict, ticker: str, sector: str, industry: str, progress_callback=None
) -> str:
    """Full-text analysis: chunk 1A+7, summarize each segment, synthesize report; then append forensic (Item 3, 9A). progress_callback(step: str) optional."""
    def _progress(msg):
        if progress_callback:
            progress_callback(msg)
    combined = (sections.get("item1a") or "") + "\n\n---\n\n" + (sections.get("item7") or "")
    combined = combined.strip()
    if not combined:
        return "No 10-K text available to analyse."
    chunks = _split_into_chunks(combined, max_chars=22000)
    if not chunks:
        return "No content extracted."
    summaries = []
    n = len(chunks)
    for i, ch in enumerate(chunks):
        _progress(f"Analyzing Segment {i+1}/{n}...")
        summary = _gemini_summarize_segment(api_key, ch, ticker, f"Segment {i+1}/{n}")
        if summary:
            summaries.append(summary)
    if not summaries:
        return "Segment analysis produced no summaries."
    _progress("Synthesizing final report...")
    report = _gemini_synthesize_report(api_key, summaries, ticker, sector or "N/A", industry or "N/A")
    _progress("Running forensic audit (Item 3 & 9A)...")
    forensic = _gemini_forensic_audit(api_key, sections.get("item3") or "", sections.get("item9a") or "", ticker)
    return (report or "") + "\n\n---\n\n**Forensic (Item 3 & 9A)**\n\n" + (forensic or "")


def get_mda_insights(api_key: str, item1a_text: str, item7_text: str, ticker: str) -> str:
    """Send Item 1A + Item 7 to Gemini. Analyse: 1) Management's Tone (Sentiment), 2) Key Strategic Shifts, 3) Major Hidden Risks."""
    model = get_gemini_model(api_key)
    combined = []
    if item1a_text:
        combined.append(clean_text_for_llm(item1a_text))
    if item7_text:
        combined.append(clean_text_for_llm(item7_text))
    combined_text = "\n\n---\n\n".join(combined)
    combined_text = smart_chunk(combined_text, max_chars=22000)

    user_prompt = f"""You are a senior equity analyst. Use British English.

The text below is from the 10-K for {ticker}: **Item 1A (Risk Factors)** and **Item 7 (Management's Discussion and Analysis)**. HTML has been stripped; analyse only the substance.

Provide a concise report with three sections:

1. **Management's Tone (Sentiment)**: Is the overall tone positive, cautious, or negative? Quote 1–2 short phrases that support your view.

2. **Key Strategic Shifts**: What strategic priorities or shifts does management emphasise (e.g. capital allocation, growth drivers, new segments)? Be specific.

3. **Major Hidden Risks**: From both Risk Factors and MD&A, what are the 3–4 most material risks that an investor might overlook? Cite the document.

Use clear headings. Do not invent figures. Keep the response focused and under 800 words."""

    full_content = f"""--- 10-K Excerpt (Item 1A + Item 7) ---\n\n{combined_text}\n\n---\n\n{user_prompt}"""

    try:
        response = _generate_with_retry(
            model, full_content, {"temperature": 0.3, "max_output_tokens": 4096}
        )
    except Exception as api_err:
        if _is_rate_limit_error(api_err):
            raise RuntimeError("Rate limit exceeded. Please try again in a few minutes.") from api_err
        raise
    if not response or not response.text:
        return "No analysis generated."
    return response.text.strip()


def get_mda_comparative_insights(
    api_key: str,
    item1a_text: str,
    item7_latest: str,
    item7_3y_ago: Optional[str],
    ticker: str,
    sector: Optional[str] = None,
    industry: Optional[str] = None,
) -> str:
    """Comparative analysis: if item7_3y_ago provided, compare MD&As over 3 years; else single-year. Sector-aware: extract industry-specific Non-GAAP KPIs."""
    model = get_gemini_model(api_key)
    sector_label = (sector or "N/A").strip()
    industry_label = (industry or "N/A").strip()
    kpi_instruction = (
        f" Given that this company is in the **{sector_label}** sector"
        + (f" (industry: {industry_label})" if industry_label != "N/A" else "")
        + ", meticulously scan the MD&A to find and extract **industry-specific Non-GAAP KPIs** "
        "(e.g. Same-Store Sales Growth for Retail, ARR/NDR for Software, DAU/MAU for Tech). Present these hidden KPIs in a **clean markdown table** with columns such as KPI name, value, and period if stated."
    )
    if not item7_3y_ago or not item7_3y_ago.strip():
        combined = []
        if item1a_text:
            combined.append(clean_text_for_llm(item1a_text))
        if item7_latest:
            combined.append(clean_text_for_llm(item7_latest))
        combined_text = "\n\n---\n\n".join(combined)
        combined_text = smart_chunk(combined_text, max_chars=22000)
        user_prompt = f"""You are a senior equity analyst. Use British English.
The text below is from the **latest 10-K only** for {ticker}: **Item 1A (Risk Factors)** and **Item 7 (MD&A)**. Provide a focused deep-dive report:

1. **Management's Tone (Sentiment)**: Overall tone and 1–2 supporting phrases.
2. **Current Strategy & Priorities**: Key strategic focus, capital allocation, growth drivers from this filing only.
3. **Major Hidden Risks**: From Item 1A and MD&A, the 3–4 most material risks investors might overlook.
4. **Forensic / Quality of Earnings**: Any red flags in MD&A (accounting caveats, one-offs, cash flow vs earnings, segment disclosure). If none material, say so briefly.{kpi_instruction}
**Token-saving (Item 3 / 9A):** If no material weaknesses, major lawsuits, or off-balance-sheet red flags, output exactly: "✅ No material red flags or special issues detected in Item 3 and 9A."
Use clear headings. Under 800 words."""
        full_content = f"""--- 10-K Excerpt (Latest Year) ---\n\n{combined_text}\n\n---\n\n{user_prompt}"""
    else:
        latest_clean = smart_chunk(clean_text_for_llm(item7_latest), max_chars=12000)
        past_clean = smart_chunk(clean_text_for_llm(item7_3y_ago), max_chars=12000)
        user_prompt = f"""You are a senior equity analyst. Use British English.
Below are **Item 7 (Management's Discussion and Analysis)** from the 10-K for {ticker}: **LATEST YEAR** and **THREE YEARS AGO**. Perform a **Comparative Analysis**.

1. **Core strategy**: What has changed in the company's stated strategy, priorities, or capital allocation between then and now?
2. **Emerging risks**: What new risks appear in the latest MD&A that were absent or less prominent 3 years ago?
3. **Management's tone**: How has the overall tone (confidence, caution, optimism) shifted? Quote 1–2 phrases from each period if relevant.
4. **Industry-specific KPIs**:{kpi_instruction}
5. **Item 3 (Legal) & Item 9A (Internal Controls):** You must save output tokens. If there are no material weaknesses, no massive lawsuits, and no major off-balance sheet red flags, DO NOT generate a long explanation. Simply output exactly: "✅ No material red flags or special issues detected in Item 3 and 9A." and move on.

Use clear headings. Do not invent figures. Keep the response focused and under 900 words."""
        full_content = f"""--- MD&A LATEST YEAR ---\n\n{latest_clean}\n\n--- MD&A THREE YEARS AGO ---\n\n{past_clean}\n\n---\n\n{user_prompt}"""
    try:
        response = _generate_with_retry(
            model, full_content, {"temperature": 0.3, "max_output_tokens": 4096}
        )
    except Exception as api_err:
        if _is_rate_limit_error(api_err):
            raise RuntimeError("Rate limit exceeded. Please try again in a few minutes.") from api_err
        raise
    if not response or not response.text:
        return "No analysis generated."
    return response.text.strip()


def _run_mda_analysis_background(ticker: str, api_key: str, sec_email: str) -> None:
    """Run download + Gemini in background (latest 10-K only for speed). Store result or error in st.session_state."""
    try:
        _, item1a, item7_latest = download_and_extract_item7_and_1a(ticker, sec_email)
        si = get_sector_industry(ticker)
        analysis = get_mda_comparative_insights(
            api_key, item1a or "", item7_latest or "", None, ticker,
            sector=si.get("sector"), industry=si.get("industry"),
        )
        st.session_state["mda_analysis_result"] = analysis
        st.session_state["mda_analysis_excerpt"] = ((item1a or "") + "\n\n---\n\n" + (item7_latest or ""))[:12000]
        st.session_state["mda_analysis_error"] = None
    except Exception as e:
        st.session_state["mda_analysis_error"] = str(e)
        st.session_state["mda_analysis_result"] = None
        st.session_state["mda_analysis_excerpt"] = None
    finally:
        st.session_state["mda_analysis_running"] = False
        st.session_state["mda_analysis_done"] = True
        st.session_state["mda_analysis_ticker"] = ticker


def get_industry_outlook(api_key: str, industry_name: str, tickers: list) -> str:
    """Gemini: Wall Street macro analyst-style Industry Outlook for the selected sector (12–18 months)."""
    model = get_gemini_model(api_key)
    ticker_list_str = ", ".join(str(t).upper() for t in tickers if t)
    user_prompt = f"""Act as an elite Wall Street macro analyst. Provide a concise **Industry Outlook** report for the **{industry_name}** sector, which includes leading companies like {ticker_list_str}.

Focus on:
1. **Macro trends** affecting this industry over the next 12–18 months.
2. **Major growth drivers** (e.g., AI, interest rates, consumer spending, regulation).
3. **Key headwinds or regulatory risks** that could impact valuations or growth.

Use clear headings. Be specific but concise. Keep the response under 600 words."""
    full_content = user_prompt
    try:
        response = _generate_with_retry(
            model, full_content, {"temperature": 0.4, "max_output_tokens": 2048}
        )
    except Exception as api_err:
        if _is_rate_limit_error(api_err):
            raise RuntimeError("Rate limit exceeded. Please try again in a few minutes.") from api_err
        raise
    if not response or not response.text:
        return "No industry outlook generated."
    return response.text.strip()


# ---------- Financial data helpers (yahooquery primary, yfinance fallback) ----------
def _safe_float(x) -> Optional[float]:
    if x is None or (isinstance(x, float) and (x != x or pd.isna(x))):
        return None
    try:
        return float(x)
    except (TypeError, ValueError):
        return None


# ---------- yahooquery: map to our index/column shape (index=line items, columns=dates) ----------
# yahooquery returns DataFrame: rows = periods, columns = asOfDate, TotalRevenue, NetIncome, ...
# Use tuples for alternate column names so F-Score and Radar get correct values.
_INCOME_ROW_MAP = [
    ("Total Revenue", ("TotalRevenue", "OperatingRevenue", "TotalRevenue")),
    ("Cost Of Revenue", ("CostOfRevenue", "ReconciledCostOfRevenue")),
    ("Gross Profit", ("GrossProfit",)),
    ("Operating Income", ("OperatingIncome", "EBIT", "TotalOperatingIncomeAsReported")),
    ("Net Income", ("NetIncome", "NetIncomeCommonStockholders", "NetIncomeContinuousOperations", "DilutedNIAvailtoComStockholders")),
    ("Operating Expense", ("OperatingExpense", "OperatingExpenses", "TotalExpenses")),
    ("Interest Expense", ("InterestExpense", "InterestExpenseNonOperating")),
    ("Research And Development Expenses", ("ResearchAndDevelopment", "ResearchAndDevelopmentExpenses")),
]
_BALANCE_ROW_MAP = [
    ("Total Assets", ("TotalAssets",)),
    ("Total Stockholder Equity", ("StockholdersEquity", "CommonStockEquity", "TotalEquityGrossMinorityInterest")),
    ("Total Liabilities", ("TotalLiabilitiesNetMinorityInterest", "TotalLiabilities")),
    ("Current Assets", ("CurrentAssets",)),
    ("Current Liabilities", ("CurrentLiabilities",)),
    ("Long Term Debt", ("LongTermDebt", "LongTermDebtAndCapitalLeaseObligation")),
    ("Total Debt", ("TotalDebt",)),
    ("Share Issued", ("OrdinarySharesNumber", "ShareIssued", "BasicAverageShares", "DilutedAverageShares")),
    ("Cash And Cash Equivalents", ("CashAndCashEquivalents", "CashCashEquivalentsAndShortTermInvestments", "EndCashPosition")),
    ("Retained Earnings", ("RetainedEarnings",)),
]
_CASHFLOW_ROW_MAP = [
    ("Operating Cash Flow", ("OperatingCashFlow", "CashFromOperatingActivities")),
    ("Capital Expenditure", ("CapitalExpenditure", "CapitalExpenditures")),
]


def _yq_df_to_our_shape(df: pd.DataFrame, row_map: list, date_col: str = "asOfDate") -> Optional[pd.DataFrame]:
    """Convert yahooquery DataFrame (rows=periods, columns=line items) to our shape: index=line names, columns=dates."""
    if df is None or df.empty or date_col not in df.columns:
        return None
    df = df.dropna(subset=[date_col]).sort_values(date_col, ascending=False).head(5)
    if df.empty:
        return None
    dates = df[date_col].astype(str).str[:10].tolist()
    data = {}
    for our_name, yq_col in row_map:
        cols = (yq_col,) if isinstance(yq_col, str) else yq_col
        val_col = next((c for c in cols if c in df.columns), None)
        if val_col is None:
            data[our_name] = [None] * len(dates)
            continue
        data[our_name] = [_safe_float(v) for v in df[val_col].tolist()]
    out = pd.DataFrame(data, index=dates).T
    out.columns = dates
    return out


def _share_issued_from_yq_balance(df_bal: pd.DataFrame) -> Optional[pd.Series]:
    """Try OrdinarySharesNumber then ShareIssued for shares outstanding in yahooquery balance."""
    if df_bal is None or df_bal.empty:
        return None
    for col in ("OrdinarySharesNumber", "ShareIssued"):
        if col in df_bal.columns and "asOfDate" in df_bal.columns:
            s = df_bal.set_index("asOfDate")[col].sort_index(ascending=False)
            s.index = s.index.astype(str).str[:10]
            return s.reindex(s.index)  # keep as series with date index
    return None


@st.cache_data(ttl=300)
def _get_annual_financials_balance_cashflow_yahooquery(ticker: str) -> tuple:
    """Fetch income, balance, cash flow from yahooquery. Return (fin_df, bal_df, cf_df) with index=line items, columns=dates. TTM fallback if annual insufficient."""
    if not YQTicker or not ticker:
        return (None, None, None)
    try:
        yq = YQTicker(ticker.upper())
        inc_a = yq.income_statement(frequency="a", trailing=False)
        bal_a = yq.balance_sheet(frequency="a", trailing=False)
        cf_a = yq.cash_flow(frequency="a", trailing=False)
        if inc_a is None or inc_a.empty or bal_a is None or bal_a.empty:
            inc_q = yq.income_statement(frequency="q", trailing=False)
            bal_q = yq.balance_sheet(frequency="q", trailing=False)
            cf_q = yq.cash_flow(frequency="q", trailing=False)
            # Build TTM: need at least 2 periods for Piotroski/Radar; use last 4Q and previous 4Q when 8+ quarters
            if inc_q is not None and not inc_q.empty and len(inc_q) >= 4:
                ttm0 = inc_q.head(4).sum(numeric_only=True)
                row0 = ttm0.to_dict() if hasattr(ttm0, "to_dict") else dict(ttm0)
                row0["asOfDate"] = inc_q["asOfDate"].iloc[0] if "asOfDate" in inc_q.columns else "TTM0"
                rows_inc = [row0]
                if len(inc_q) >= 8:
                    ttm1 = inc_q.iloc[4:8].sum(numeric_only=True)
                    row1 = ttm1.to_dict() if hasattr(ttm1, "to_dict") else dict(ttm1)
                    row1["asOfDate"] = inc_q["asOfDate"].iloc[4] if "asOfDate" in inc_q.columns else "TTM1"
                    rows_inc.append(row1)
                inc_a = pd.DataFrame(rows_inc)
            if bal_q is not None and not bal_q.empty:
                bal_a = bal_q.head(2) if (bal_a is None or bal_a.empty) else bal_a
            if cf_q is not None and not cf_q.empty and len(cf_q) >= 4 and (cf_a is None or cf_a.empty):
                ttm0_cf = cf_q.head(4).sum(numeric_only=True)
                row0_cf = ttm0_cf.to_dict() if hasattr(ttm0_cf, "to_dict") else dict(ttm0_cf)
                row0_cf["asOfDate"] = cf_q["asOfDate"].iloc[0] if "asOfDate" in cf_q.columns else "TTM0"
                rows_cf = [row0_cf]
                if len(cf_q) >= 8:
                    ttm1_cf = cf_q.iloc[4:8].sum(numeric_only=True)
                    row1_cf = ttm1_cf.to_dict() if hasattr(ttm1_cf, "to_dict") else dict(ttm1_cf)
                    row1_cf["asOfDate"] = cf_q["asOfDate"].iloc[4] if "asOfDate" in cf_q.columns else "TTM1"
                    rows_cf.append(row1_cf)
                cf_a = pd.DataFrame(rows_cf)
        fin_df = _yq_df_to_our_shape(inc_a, _INCOME_ROW_MAP)
        bal_df = _yq_df_to_our_shape(bal_a, _BALANCE_ROW_MAP)
        if bal_df is not None and "Share Issued" not in bal_df.index and bal_a is not None and not bal_a.empty:
            for sh_col in ("OrdinarySharesNumber", "ShareIssued"):
                if sh_col in bal_a.columns:
                    row = {"Share Issued": [_safe_float(bal_a[sh_col].iloc[0])]}
                    if bal_df is not None and not bal_df.empty:
                        d = str(bal_a["asOfDate"].iloc[0])[:10] if "asOfDate" in bal_a.columns else bal_df.columns[0]
                        extra = pd.DataFrame(row, index=[d]).T
                        extra.columns = [d]
                        bal_df = pd.concat([bal_df, extra], axis=0)
                    break
        cf_df = _yq_df_to_our_shape(cf_a, _CASHFLOW_ROW_MAP)
        return (fin_df, bal_df, cf_df)
    except Exception:
        return (None, None, None)


# ---------- Raw statements & FCF = OCF - CapEx ----------
def _get_row_series(df: pd.DataFrame, *names: str) -> Optional[pd.Series]:
    if df is None or df.empty:
        return None
    for name in names:
        try:
            if name in df.index:
                return df.loc[name].copy()
        except (KeyError, TypeError):
            continue
    return None


def _fin_or_bal_empty(df) -> bool:
    """True if DataFrame is missing, empty, or has no columns (e.g. yfinance returned empty)."""
    return df is None or df.empty or (hasattr(df, "columns") and len(df.columns) == 0)


@st.cache_data(ttl=300)
def _get_annual_financials_balance_cashflow(ticker: str) -> tuple:
    """Return (fin_df, bal_df, cf_df). Uses yahooquery first; if missing/fail, falls back to yfinance with TTM when needed."""
    if not ticker:
        return (None, None, None)
    fin_df, bal_df, cf_df = _get_annual_financials_balance_cashflow_yahooquery(ticker)
    if fin_df is not None and not fin_df.empty and bal_df is not None and not bal_df.empty:
        return (fin_df, bal_df, cf_df)
    if not yf:
        return (None, None, None)
    try:
        t = yf.Ticker(ticker.upper())
        fin = getattr(t, "financials", None)
        bal = getattr(t, "balance_sheet", None)
        cf = getattr(t, "cashflow", None)
        if _fin_or_bal_empty(fin):
            qf = getattr(t, "quarterly_financials", None)
            if qf is not None and not qf.empty:
                n = len(qf.columns)
                if n >= 8:
                    c0 = qf.iloc[:, :4].sum(axis=1)
                    c1 = qf.iloc[:, 4:8].sum(axis=1)
                    fin = pd.concat([c0, c1], axis=1)
                    fin.columns = ["TTM0", "TTM1"]
                elif n >= 5:
                    c0 = qf.iloc[:, :4].sum(axis=1)
                    c1 = qf.iloc[:, 4:n].sum(axis=1)
                    fin = pd.concat([c0, c1], axis=1)
                    fin.columns = ["TTM0", "TTM1"]
                else:
                    fin = qf.iloc[:, : min(4, n)].sum(axis=1).to_frame("TTM0")
        if _fin_or_bal_empty(bal):
            qb = getattr(t, "quarterly_balance_sheet", None)
            if qb is not None and not qb.empty:
                n = len(qb.columns)
                bal = qb.iloc[:, : min(2, n)].copy()
                if bal.shape[1] == 1:
                    bal.columns = ["B0"]
                else:
                    bal.columns = ["B0", "B1"]
        if _fin_or_bal_empty(cf):
            qc = getattr(t, "quarterly_cashflow", None)
            if qc is not None and not qc.empty:
                n = len(qc.columns)
                cf = qc.iloc[:, : min(4, n)].sum(axis=1).to_frame("TTM0")
        return (fin, bal, cf)
    except Exception:
        return (None, None, None)


@st.cache_data(ttl=300)
def get_sector_industry(ticker: str) -> dict:
    """Return sector and industry from yfinance. Fallback to N/A."""
    if not yf:
        return {"sector": "N/A", "industry": "N/A"}
    try:
        t = yf.Ticker(ticker.upper())
        info = t.info or {}
        sector = (info.get("sector") or info.get("sectorDisp") or "N/A").strip() or "N/A"
        industry = (info.get("industry") or info.get("industryDisp") or "N/A").strip() or "N/A"
        return {"sector": sector, "industry": industry}
    except Exception:
        return {"sector": "N/A", "industry": "N/A"}


@st.cache_data(ttl=300)
def get_5yr_financial_trend(ticker: str) -> pd.DataFrame:
    """Extract up to 5 years: Revenue, Net Income, Operating Margin, FCF (OCF - CapEx). Handles missing years."""
    if not yf:
        return pd.DataFrame()
    try:
        t = yf.Ticker(ticker.upper())
        financials = t.financials  # annual
        cashflow = t.cashflow
        if financials is None or financials.empty or cashflow is None or cashflow.empty:
            return pd.DataFrame()
        dates = sorted(financials.columns.tolist(), reverse=True)[:5]
        ocf = _get_row_series(cashflow, "Operating Cash Flow", "Cash From Operating Activities", "Cash From Operations")
        capx = _get_row_series(cashflow, "Capital Expenditure", "Capital Expenditures", "Purchase Of Property Plant And Equipment")
        revenue = _get_row_series(financials, "Total Revenue", "Revenue", "Net Revenue")
        ni = _get_row_series(financials, "Net Income", "Net Income Common Stockholders")
        op_income = _get_row_series(financials, "Operating Income", "EBIT")
        rows = []
        cashflow_cols = list(cashflow.columns) if cashflow is not None else []
        for d in dates:
            yr = d.year if hasattr(d, "year") else int(str(d)[:4])
            rev = _safe_float(revenue.get(d)) if revenue is not None and d in revenue.index else None
            net_i = _safe_float(ni.get(d)) if ni is not None and d in ni.index else None
            op_i = _safe_float(op_income.get(d)) if op_income is not None and d in op_income.index else None
            oper_margin = (op_i / rev * 100) if (op_i is not None and rev and rev != 0) else ((net_i / rev * 100) if (net_i is not None and rev and rev != 0) else None)
            ocf_val = _safe_float(ocf.get(d)) if ocf is not None and d in ocf.index else None
            if ocf_val is None and ocf is not None and cashflow_cols:
                for c in cashflow_cols:
                    if (getattr(c, "year", None) or int(str(c)[:4])) == yr:
                        ocf_val = _safe_float(ocf.get(c))
                        break
            capx_val = _safe_float(capx.get(d)) if capx is not None and d in capx.index else None
            if capx_val is None and capx is not None and cashflow_cols:
                for c in cashflow_cols:
                    if (getattr(c, "year", None) or int(str(c)[:4])) == yr:
                        capx_val = _safe_float(capx.get(c))
                        break
            if ocf_val is not None and capx_val is not None:
                fcf = ocf_val - capx_val
            elif ocf_val is not None:
                fcf = ocf_val
            else:
                fcf = None
            rows.append({
                "Year": yr,
                "Revenue": rev,
                "Net Income": net_i,
                "Operating Margin %": round(oper_margin, 2) if oper_margin is not None else None,
                "FCF": fcf,
            })
        return pd.DataFrame(rows)
    except Exception:
        return pd.DataFrame()


def _format_shares_display(shares: float) -> str:
    """Format share count for UI, e.g. 15.42B Shares or 1.2B Shares."""
    if shares is None or shares <= 0:
        return "N/A"
    s = float(shares)
    if s >= 1e9:
        return f"{s / 1e9:.2f}B Shares"
    if s >= 1e6:
        return f"{s / 1e6:.2f}M Shares"
    if s >= 1e3:
        return f"{s / 1e3:.2f}K Shares"
    return f"{s:.0f} Shares"


@st.cache_data(ttl=300)
def get_dcf_inputs(ticker: str) -> dict:
    """FCF, Cash, Total Debt, Shares: from yahooquery (via _get_annual_financials) or yfinance fallback."""
    out = {"fcf": None, "total_debt": 0.0, "cash": 0.0, "shares": None}
    if not ticker:
        return out
    try:
        fin, bal, cf = _get_annual_financials_balance_cashflow(ticker)
        if bal is not None and not bal.empty and cf is not None and not cf.empty:
            sh = _get_row_series(bal, "Share Issued")
            out["shares"] = _safe_float(sh.iloc[0]) if sh is not None and len(sh) > 0 else None
            td = _get_row_series(bal, "Total Debt")
            out["total_debt"] = float(td.iloc[0] or 0) if td is not None and len(td) > 0 else 0.0
            cash_s = _get_row_series(bal, "Cash And Cash Equivalents")
            out["cash"] = float(cash_s.iloc[0] or 0) if cash_s is not None and len(cash_s) > 0 else 0.0
            ocf = _get_row_series(cf, "Operating Cash Flow")
            capx = _get_row_series(cf, "Capital Expenditure")
            if ocf is not None and len(ocf) > 0:
                ocf_val = _safe_float(ocf.iloc[0])
                capx_val = _safe_float(capx.iloc[0]) if capx is not None and len(capx) > 0 else 0.0
                if ocf_val is not None:
                    out["fcf"] = ocf_val - (capx_val or 0)
            if out.get("fcf") is not None or out.get("shares") is not None:
                return out
    except Exception:
        pass
    if not yf:
        return out
    try:
        t = yf.Ticker(ticker.upper())
        info = t.info or {}
        fast_info = getattr(t, "fast_info", None)
        cashflow = getattr(t, "cashflow", None)
        if cashflow is None or cashflow.empty:
            cashflow = getattr(t, "quarterly_cashflow", None)
        balance = getattr(t, "balance_sheet", None)
        if balance is None or balance.empty:
            balance = getattr(t, "quarterly_balance_sheet", None)

        # ----- Shares Outstanding: multi-step fallback (no manual by default) -----
        shares = None
        if fast_info is not None:
            try:
                s = getattr(fast_info, "shares", None)
                if s is None and hasattr(fast_info, "get"):
                    s = fast_info.get("shares")
                if s is not None and float(s) > 0:
                    shares = float(s)
            except (TypeError, ValueError, AttributeError):
                pass
        if shares is None:
            for key in ("sharesOutstanding", "Shares Outstanding", "impliedSharesOutstanding", "Float Shares"):
                s = info.get(key)
                if s is not None and float(s) > 0:
                    shares = float(s)
                    break
        if shares is None and balance is not None and not balance.empty:
            try:
                if "Share Issued" in balance.index:
                    shares = _safe_float(balance.loc["Share Issued"].iloc[0])
                if (shares is None or shares <= 0) and "Ordinary Shares Number" in balance.index:
                    shares = _safe_float(balance.loc["Ordinary Shares Number"].iloc[0])
            except (KeyError, TypeError, IndexError):
                pass
        out["shares"] = shares if (shares is not None and shares > 0) else None

        # ----- Total Debt: fast_info → info → balance -----
        total_debt = None
        if fast_info is not None:
            try:
                d = getattr(fast_info, "total_debt", None) or (fast_info.get("total_debt") if hasattr(fast_info, "get") else None)
                if d is not None and float(d) >= 0:
                    total_debt = float(d)
            except (TypeError, ValueError, AttributeError):
                pass
        if total_debt is None:
            total_debt = info.get("Total Debt")
        if total_debt is None and balance is not None and not balance.empty:
            try:
                if "Total Debt" in balance.index:
                    total_debt = _safe_float(balance.loc["Total Debt"].iloc[0])
            except (KeyError, TypeError, IndexError):
                pass
        out["total_debt"] = float(total_debt) if total_debt is not None else 0.0

        # ----- Cash: fast_info → info → balance -----
        cash = None
        if fast_info is not None:
            try:
                c = getattr(fast_info, "cash", None) or (fast_info.get("cash") if hasattr(fast_info, "get") else None)
                if c is not None and float(c) >= 0:
                    cash = float(c)
            except (TypeError, ValueError, AttributeError):
                pass
        if cash is None:
            cash = info.get("Cash And Cash Equivalents") or info.get("Cash")
        if cash is None and balance is not None and not balance.empty:
            try:
                for row in ("Cash And Cash Equivalents", "Cash Cash Equivalents And Short Term Investments", "Cash"):
                    if row in balance.index:
                        cash = _safe_float(balance.loc[row].iloc[0])
                        if cash is not None:
                            break
            except (KeyError, TypeError, IndexError):
                pass
        out["cash"] = float(cash) if cash is not None else 0.0

        # ----- Base FCF = OCF - CapEx -----
        ocf = _get_row_series(cashflow, "Operating Cash Flow", "Cash From Operating Activities", "Cash From Operations") if cashflow is not None else None
        capx = _get_row_series(cashflow, "Capital Expenditure", "Capital Expenditures", "Purchase Of Property Plant And Equipment") if cashflow is not None else None
        if ocf is not None and len(ocf) > 0:
            latest_date = ocf.index[0]
            ocf_val = _safe_float(ocf.iloc[0])
            capx_val = _safe_float(capx.get(latest_date)) if (capx is not None and hasattr(capx, "index") and latest_date in getattr(capx, "index", [])) else (_safe_float(capx.iloc[0]) if capx is not None and len(capx) > 0 else None)
            if capx_val is None:
                capx_val = 0.0
            if ocf_val is not None:
                latest_fcf = ocf_val - capx_val
                if latest_fcf == latest_fcf and not (isinstance(latest_fcf, float) and pd.isna(latest_fcf)):
                    out["fcf"] = latest_fcf
        return out
    except Exception:
        return out


def dcf_intrinsic_value(fcf: float, wacc: float, terminal_growth: float, fcf_growth: float, years: int = 5) -> float:
    """5-year DCF: project FCF with fcf_growth, then terminal value; discount at WACC. Returns enterprise value. Robust: avoids div by zero."""
    if fcf is None or fcf <= 0:
        return 0.0
    if wacc <= terminal_growth or wacc <= 0:
        return 0.0
    pv = 0.0
    fcft = float(fcf)
    for t in range(1, years + 1):
        pv += fcft / ((1 + wacc) ** t)
        fcft *= (1 + fcf_growth)
    terminal_fcf = fcft
    tv = terminal_fcf * (1 + terminal_growth) / (wacc - terminal_growth)
    pv += tv / ((1 + wacc) ** years)
    return pv


def dcf_10y_2stage(fcf: float, wacc: float, term_growth: float, fcf_growth: float) -> float:
    """10-Year 2-Stage DCF. Stage 1 (Y1–5): FCF grows at fcf_growth. Stage 2 (Y6–10): growth linearly fades from fcf_growth to term_growth by Y10. TV at Y10; discount all to PV."""
    if fcf is None or fcf <= 0:
        return 0.0
    if wacc <= term_growth or wacc <= 0:
        return 0.0
    pv = 0.0
    fcft = float(fcf)
    for t in range(1, 6):
        pv += fcft / ((1 + wacc) ** t)
        fcft *= (1 + fcf_growth)
    for t in range(6, 11):
        fade = (t - 6) / 4.0
        g_t = fcf_growth + fade * (term_growth - fcf_growth)
        fcft *= (1 + g_t)
        pv += fcft / ((1 + wacc) ** t)
    tv = fcft * (1 + term_growth) / (wacc - term_growth)
    pv += tv / ((1 + wacc) ** 10)
    return pv


def excel_style_dcf(fcf_base: float, wacc: float, term_growth: float, fcf_growth: float, total_debt: float, cash: float, shares: float) -> dict:
    """10Y 2-Stage DCF: EV = PV(FCF Y1–10) + PV(TV); Equity = EV - Debt + Cash; Value per share = Equity / Shares."""
    ev = dcf_10y_2stage(fcf_base, wacc, term_growth, fcf_growth)
    equity = ev - total_debt + cash
    shares_safe = float(shares) if (shares is not None and float(shares) > 0) else None
    value_per_share = (equity / shares_safe) if shares_safe else None
    return {"ev": ev, "equity_value": equity, "value_per_share": value_per_share, "shares": shares_safe}


# Aswath Damodaran sector WACC (approx. 2024/2025 baseline). Used for reference in DCF panel.
DAMODARAN_WACC = {
    "Software": 8.5,
    "Retail": 7.5,
    "Hardware": 9.0,
    "Financials": 8.0,
    "Healthcare": 7.2,
    "Consumer": 7.5,
    "Technology": 8.5,
    "Industrial": 7.8,
    "Energy": 8.2,
    "Utilities": 6.5,
}
DAMODARAN_ERP_PCT = 4.6
DAMODARAN_RF_PCT = 4.2


def _damodaran_wacc_for_sector(sector: str) -> float:
    """Map yfinance sector string to closest Damodaran WACC. Default 8.0%."""
    if not sector:
        return 8.0
    s = (sector or "").lower()
    if "software" in s or "technology" in s or "internet" in s:
        return DAMODARAN_WACC.get("Software", 8.5)
    if "hardware" in s or "semiconductor" in s:
        return DAMODARAN_WACC.get("Hardware", 9.0)
    if "retail" in s or "consumer" in s or "cyclical" in s:
        return DAMODARAN_WACC.get("Retail", 7.5)
    if "financial" in s or "bank" in s or "insurance" in s:
        return DAMODARAN_WACC.get("Financials", 8.0)
    if "health" in s or "pharma" in s:
        return DAMODARAN_WACC.get("Healthcare", 7.2)
    if "industrial" in s:
        return DAMODARAN_WACC.get("Industrial", 7.8)
    if "energy" in s or "oil" in s:
        return DAMODARAN_WACC.get("Energy", 8.2)
    if "utilities" in s:
        return DAMODARAN_WACC.get("Utilities", 6.5)
    return 8.0


@st.cache_data(ttl=300)
def get_analyst_consensus(ticker: str) -> dict:
    """Fetch analyst consensus from yfinance: targetMeanPrice, recommendationKey, revenueGrowth, earningsGrowth. Missing → N/A."""
    out = {"targetMeanPrice": "N/A", "recommendationKey": "N/A", "revenueGrowth": "N/A", "earningsGrowth": "N/A"}
    if not yf or not ticker:
        return out
    try:
        t = yf.Ticker(ticker.upper())
        info = t.info or {}
        tp = info.get("targetMeanPrice")
        if tp is not None:
            try:
                out["targetMeanPrice"] = f"${float(tp):.2f}"
            except (TypeError, ValueError):
                out["targetMeanPrice"] = str(tp)
        rec = info.get("recommendationKey") or info.get("recommendation")
        if rec is not None:
            out["recommendationKey"] = str(rec)
        rg = info.get("revenueGrowth")
        if rg is not None:
            try:
                out["revenueGrowth"] = f"{float(rg) * 100:.1f}%"
            except (TypeError, ValueError):
                out["revenueGrowth"] = str(rg)
        eg = info.get("earningsGrowth")
        if eg is not None:
            try:
                out["earningsGrowth"] = f"{float(eg) * 100:.1f}%"
            except (TypeError, ValueError):
                out["earningsGrowth"] = str(eg)
        return out
    except Exception:
        return out


@st.cache_data(ttl=300)
def get_dcf_smart_defaults(ticker: str) -> dict:
    """Smart default assumptions: WACC from CAPM (Beta), Terminal Growth = 2.5%, FCF Growth from revenueGrowth/earningsGrowth or 8%."""
    out = {"wacc_pct": 10.0, "term_growth_pct": 2.5, "fcf_growth_pct": 8.0}
    if not yf or not ticker:
        return out
    try:
        t = yf.Ticker(ticker.upper())
        info = t.info or {}
        beta = info.get("beta")
        if beta is None:
            beta = 1.0
        else:
            try:
                beta = float(beta)
            except (TypeError, ValueError):
                beta = 1.0
        risk_free = 4.0
        market_risk_premium = 5.0
        calculated_wacc = risk_free + (beta * market_risk_premium)
        out["wacc_pct"] = round(min(20.0, max(4.0, calculated_wacc)), 1)
        out["term_growth_pct"] = 2.5
        rev_growth = info.get("revenueGrowth") or info.get("earningsGrowth")
        if rev_growth is not None:
            try:
                g = float(rev_growth)
                out["fcf_growth_pct"] = round(min(30.0, max(-10.0, g * 100)), 1)
            except (TypeError, ValueError):
                pass
        return out
    except Exception:
        return out


# ---------- yfinance: Comps (multiples) ----------
@st.cache_data(ttl=300)
def get_comps_data(tickers: tuple) -> pd.DataFrame:
    """Fetch Forward P/E, EV/EBITDA, P/B using forwardPE, enterpriseToEbitda, priceToBook. Missing → None (display as N/A). Robust per-ticker error handling."""
    if not yf:
        return pd.DataFrame()
    rows = []
    for sym in tickers:
        sym = str(sym).strip().upper()
        if not sym:
            continue
        try:
            t = yf.Ticker(sym)
            info = t.info or {}
            forward_pe = info.get("forwardPE") or info.get("Forward PE") or info.get("trailingPE") or info.get("Trailing PE")
            ev_ebitda = info.get("enterpriseToEbitda")
            if ev_ebitda is None:
                ev, ebitda = info.get("enterpriseValue"), info.get("ebitda")
                if ev is not None and ebitda is not None and ebitda != 0:
                    ev_ebitda = ev / ebitda
            pb = info.get("priceToBook") or info.get("Price To Book")
            rows.append({
                "Ticker": sym,
                "Forward P/E": round(float(forward_pe), 2) if forward_pe is not None and _safe_float(forward_pe) is not None else None,
                "EV/EBITDA": round(float(ev_ebitda), 2) if ev_ebitda is not None and _safe_float(ev_ebitda) is not None else None,
                "P/B": round(float(pb), 2) if pb is not None and _safe_float(pb) is not None else None,
            })
        except Exception:
            rows.append({"Ticker": sym, "Forward P/E": None, "EV/EBITDA": None, "P/B": None})
    if not rows:
        return pd.DataFrame()
    return pd.DataFrame(rows)


# ---------- DuPont, Altman Z, Red Flags, YoY (2–3 years) ----------
def _na(x):
    """Return N/A for None/NaN, else value (for display)."""
    if x is None or (isinstance(x, float) and (pd.isna(x) or x != x)):
        return "N/A"
    return x


@st.cache_data(ttl=300)
def get_dupont_altman_redflags_yoy(ticker: str) -> dict:
    """Returns DuPont (3-step ROE), Altman Z-Score, red flags, YoY. Uses yahooquery then yfinance with TTM fallback."""
    try:
        fin, bal, _ = _get_annual_financials_balance_cashflow(ticker)
        if fin is None or fin.empty or bal is None or bal.empty:
            return {}
        t = yf.Ticker(ticker.upper())
        info = t.info or {}
        # TTM columns: keep order TTM0 (current), TTM1 (prior). Else use date sort (newest first).
        col_list = fin.columns.tolist()
        if col_list and str(col_list[0]).startswith("TTM"):
            dates = col_list[:3]
        else:
            dates = sorted(col_list, reverse=True)[:3]
        if not dates:
            return {}
        rev = _get_row_series(fin, "Total Revenue", "Revenue", "Net Revenue")
        ni = _get_row_series(fin, "Net Income", "Net Income Common Stockholders")
        ebit = _get_row_series(fin, "Operating Income", "EBIT")
        gross = _get_row_series(fin, "Gross Profit")
        interest = _get_row_series(fin, "Interest Expense", "Interest Expense Net")
        total_assets = _get_row_series(bal, "Total Assets")
        total_equity = _get_row_series(bal, "Total Stockholder Equity", "Stockholders Equity", "Total Equity Gross Minority Interest")
        current_assets = _get_row_series(bal, "Current Assets")
        current_liab = _get_row_series(bal, "Current Liabilities")
        retained = _get_row_series(bal, "Retained Earnings")
        total_liab = _get_row_series(bal, "Total Liabilities")
        market_cap = info.get("marketCap") or info.get("Market Cap")
        def _v(s, d):
            if s is None or d not in s.index:
                return None
            return _safe_float(s.get(d))
        rows = []
        for i, d in enumerate(dates):
            yr = int(str(d)[:4]) if (isinstance(d, str) and str(d)[:4].isdigit()) else (d.year if hasattr(d, "year") else (2024 - i))
            r = _v(rev, d)
            net_i = _v(ni, d)
            ta = _v(total_assets, d)
            te = _v(total_equity, d)
            if ta and ta > 0 and te and te > 0 and r and r != 0:
                npm = (net_i / r * 100) if net_i is not None else None
                at = r / ta if r and ta else None
                em = ta / te if ta and te else None
                roe = (net_i / te * 100) if (net_i and te) else (npm * at * em / 100 if (npm and at and em) else None)
            else:
                npm = at = em = roe = None
            gross_p = _v(gross, d)
            gross_margin = (gross_p / r * 100) if (gross_p and r and r != 0) else None
            op_inc = _v(ebit, d)
            op_margin = (op_inc / r * 100) if (op_inc and r and r != 0) else None
            ca = _v(current_assets, d)
            cl = _v(current_liab, d)
            current_ratio = (ca / cl) if (ca and cl and cl != 0) else None
            int_exp = _v(interest, d)
            if op_inc is not None and int_exp is not None and int_exp != 0:
                _ic = op_inc / int_exp
                interest_cov = round(_ic, 2) if (_ic == _ic and not (isinstance(_ic, float) and (pd.isna(_ic) or _ic != _ic))) else None
            else:
                interest_cov = None  # N/A when Interest Expense is 0 or missing (avoid nan%)
            rows.append({
                "Year": yr,
                "Revenue": r, "Net Income": net_i,
                "NPM %": round(npm, 2) if npm is not None else None,
                "Asset Turnover": round(at, 4) if at is not None else None,
                "Equity Mult.": round(em, 2) if em is not None else None,
                "ROE %": round(roe, 2) if roe is not None else None,
                "Gross Margin %": round(gross_margin, 2) if gross_margin is not None else None,
                "Operating Margin %": round(op_margin, 2) if op_margin is not None else None,
                "Current Ratio": round(current_ratio, 2) if current_ratio is not None else None,
                "Interest Coverage": interest_cov,
            })
        dupont_df = pd.DataFrame(rows)
        yoy = []
        if len(dupont_df) >= 2:
            for col in ["NPM %", "ROE %", "Gross Margin %", "Operating Margin %", "Current Ratio", "Interest Coverage"]:
                if col not in dupont_df.columns:
                    continue
                cur = dupont_df[col].iloc[0]
                prev = dupont_df[col].iloc[1]
                if cur is not None and prev is not None and prev != 0 and not (pd.isna(cur) or pd.isna(prev)):
                    if "Margin" in col or "NPM" in col or "ROE" in col:
                        chg_pp = (cur - prev)  # percentage point change (e.g. 7.0 = 7%)
                        if pd.isna(chg_pp) or chg_pp != chg_pp:
                            continue
                        yoy.append({"Ratio": col, "Latest": cur, "Prior": prev, "YoY (pp)": round(chg_pp, 2), "Comment": f"{'Improved' if chg_pp > 0 else 'Declined'} by {abs(chg_pp):.1f}% YoY"})
                    else:
                        pct = (cur - prev) / abs(prev) * 100
                        if pd.isna(pct) or pct != pct:
                            continue
                        yoy.append({"Ratio": col, "Latest": cur, "Prior": prev, "YoY %": round(pct, 1), "Comment": f"{'Up' if pct > 0 else 'Down'} {abs(round(pct, 1))}% YoY"})
        latest_bal_d = bal.columns[0]
        wc = (_v(current_assets, latest_bal_d) or 0) - (_v(current_liab, latest_bal_d) or 0)
        ta_l = _v(total_assets, latest_bal_d)
        re_l = _v(retained, latest_bal_d)
        tl_l = _v(total_liab, latest_bal_d)
        ebit_l = _v(ebit, fin.columns[0])
        sales_l = _v(rev, fin.columns[0])
        altman_z = None
        if ta_l and ta_l > 0 and market_cap is not None and tl_l and tl_l != 0 and sales_l:
            a = wc / ta_l
            b = (re_l or 0) / ta_l
            c = (ebit_l or 0) / ta_l
            d = market_cap / tl_l
            e = sales_l / ta_l
            altman_z = 1.2 * a + 1.4 * b + 3.3 * c + 0.6 * d + 1.0 * e
        red_flags = []
        if len(dupont_df) > 0:
            row0 = dupont_df.iloc[0]
            cr = row0.get("Current Ratio")
            if cr is not None and cr < 1.0:
                red_flags.append({"metric": "Current Ratio", "value": cr, "threshold": 1.0, "flag": "WARNING", "comment": "Current assets do not cover current liabilities; liquidity risk."})
            ic = row0.get("Interest Coverage")
            if ic is not None and ic < 1.5:
                red_flags.append({"metric": "Interest Coverage", "value": ic, "threshold": 1.5, "flag": "WARNING", "comment": "EBIT barely covers interest; default risk."})
        return {
            "dupont": dupont_df,
            "yoy": yoy,
            "altman_z": round(altman_z, 2) if altman_z is not None else None,
            "red_flags": red_flags,
        }
    except (KeyError, TypeError, ZeroDivisionError, IndexError) as e:
        return {}
    except Exception:
        return {}


@st.cache_data(ttl=300)
def get_quarterly_momentum(ticker: str) -> dict:
    """Last 4 quarters Revenue and Net Income from quarterly_financials; QoQ growth for most recent quarter. Returns {df, qoq_revenue_pct, qoq_ni_pct} or empty."""
    out = {"df": None, "qoq_revenue_pct": None, "qoq_ni_pct": None}
    if not yf or not ticker:
        return out
    try:
        t = yf.Ticker(ticker.upper())
        qfin = getattr(t, "quarterly_financials", None)
        if qfin is None or qfin.empty or len(qfin.columns) < 2:
            return out
        rev = _get_row_series(qfin, "Total Revenue", "Revenue", "Net Revenue")
        ni = _get_row_series(qfin, "Net Income", "Net Income Common Stockholders")
        if rev is None and ni is None:
            return out
        cols = list(qfin.columns)[:4]
        rows = []
        for c in cols:
            try:
                if hasattr(c, "strftime"):
                    q = (c.month - 1) // 3 + 1 if hasattr(c, "month") else 1
                    label = c.strftime("%Y") + f"-Q{q}"
                else:
                    label = str(c)[:12]
            except Exception:
                label = str(c)[:12]
            r_val = _safe_float(rev.loc[c]) if rev is not None and c in rev.index else None
            n_val = _safe_float(ni.loc[c]) if ni is not None and c in ni.index else None
            rows.append({"Quarter": label, "Revenue": r_val, "Net Income": n_val})
        out["df"] = pd.DataFrame(rows)
        if len(rows) >= 2:
            r0, r1 = rows[0].get("Revenue"), rows[1].get("Revenue")
            n0, n1 = rows[0].get("Net Income"), rows[1].get("Net Income")
            if r0 is not None and r1 is not None and r1 != 0:
                out["qoq_revenue_pct"] = round((r0 - r1) / abs(r1) * 100, 1)
            if n0 is not None and n1 is not None and n1 != 0:
                out["qoq_ni_pct"] = round((n0 - n1) / abs(n1) * 100, 1)
        return out
    except Exception:
        return out


@st.cache_data(ttl=300)
def get_quarterly_ratio_changes(ticker: str) -> list:
    """QoQ ratio changes: NPM %, ROE %, Gross Margin %, Operating Margin %, Current Ratio, Interest Coverage. Latest quarter vs previous. Returns list of {Metric, Current, Change, Trend}."""
    out = []
    if not yf or not ticker:
        return out
    try:
        t = yf.Ticker(ticker.upper())
        qf = getattr(t, "quarterly_financials", None)
        qb = getattr(t, "quarterly_balance_sheet", None)
        if qf is None or qf.empty or qb is None or qb.empty or len(qf.columns) < 2 or len(qb.columns) < 2:
            return out
        rev = _get_row_series(qf, "Total Revenue", "Revenue", "Net Revenue")
        ni = _get_row_series(qf, "Net Income", "Net Income Common Stockholders")
        gross = _get_row_series(qf, "Gross Profit")
        ebit = _get_row_series(qf, "Operating Income", "EBIT")
        interest = _get_row_series(qf, "Interest Expense", "Interest Expense Net")
        ta = _get_row_series(qb, "Total Assets")
        te = _get_row_series(qb, "Total Stockholder Equity", "Stockholders Equity", "Total Equity Gross Minority Interest")
        ca = _get_row_series(qb, "Current Assets")
        cl = _get_row_series(qb, "Current Liabilities")
        def v(s, col):
            if s is None or col not in s.index:
                return None
            return _safe_float(s.get(col))
        c0, c1 = qf.columns[0], qf.columns[1]
        b0, b1 = qb.columns[0], qb.columns[1]
        r0, r1 = v(rev, c0), v(rev, c1)
        n0, n1 = v(ni, c0), v(ni, c1)
        g0, g1 = v(gross, c0), v(gross, c1)
        e0, e1 = v(ebit, c0), v(ebit, c1)
        i0, i1 = v(interest, c0), v(interest, c1)
        ta0, ta1 = v(ta, b0), v(ta, b1)
        te0, te1 = v(te, b0), v(te, b1)
        ca0, ca1 = v(ca, b0), v(ca, b1)
        cl0, cl1 = v(cl, b0), v(cl, b1)
        npm0 = (n0 / r0 * 100) if (n0 is not None and r0 and r0 != 0) else None
        npm1 = (n1 / r1 * 100) if (n1 is not None and r1 and r1 != 0) else None
        roe0 = (n0 / te0 * 100) if (n0 is not None and te0 and te0 != 0) else None
        roe1 = (n1 / te1 * 100) if (n1 is not None and te1 and te1 != 0) else None
        gm0 = (g0 / r0 * 100) if (g0 is not None and r0 and r0 != 0) else None
        gm1 = (g1 / r1 * 100) if (g1 is not None and r1 and r1 != 0) else None
        om0 = (e0 / r0 * 100) if (e0 is not None and r0 and r0 != 0) else None
        om1 = (e1 / r1 * 100) if (e1 is not None and r1 and r1 != 0) else None
        cr0 = (ca0 / cl0) if (ca0 is not None and cl0 and cl0 != 0) else None
        cr1 = (ca1 / cl1) if (ca1 is not None and cl1 and cl1 != 0) else None
        ic0 = (e0 / i0) if (e0 is not None and i0 and i0 != 0) else None
        ic1 = (e1 / i1) if (e1 is not None and i1 and i1 != 0) else None
        def row(metric, cur, prev, is_pct_point=False):
            if cur is None:
                return None
            if prev is None or (is_pct_point and prev != prev):
                return {"Metric": metric, "Current Value": round(cur, 2), "Change": "—", "Trend": "—"}
            if is_pct_point:
                chg = cur - prev
            else:
                chg = ((cur - prev) / abs(prev) * 100) if prev != 0 else 0
            trend = "↑" if chg > 0 else ("↓" if chg < 0 else "—")
            chg_str = f"{chg:+.1f}%" if not is_pct_point else f"{chg:+.1f} pp"
            return {"Metric": metric, "Current Value": round(cur, 2), "Change": chg_str, "Trend": trend}
        for name, cur, prev, is_pp in [
            ("NPM %", npm0, npm1, True), ("ROE %", roe0, roe1, True), ("Gross Margin %", gm0, gm1, True),
            ("Operating Margin %", om0, om1, True), ("Current Ratio", cr0, cr1, False), ("Interest Coverage", ic0, ic1, False),
        ]:
            r = row(name, cur, prev, is_pp)
            if r:
                out.append(r)
        return out
    except Exception:
        return out


@st.cache_data(ttl=300)
def get_income_statement_sankey_data(ticker: str) -> dict:
    """Latest year (or TTM): Revenue, COGS, Gross Profit, OpEx, Operating Income, Tax/Interest/Other, Net Income. Uses yahooquery then yfinance."""
    out = {"revenue": 0, "cogs": 0, "gross_profit": 0, "opex": 0, "operating_income": 0, "tax_interest_other": 0, "net_income": 0}
    fin, _, _ = _get_annual_financials_balance_cashflow(ticker)
    if fin is None or fin.empty:
        return out
    try:
        rev = _get_row_series(fin, "Total Revenue", "Revenue", "Net Revenue")
        cogs = _get_row_series(fin, "Cost Of Revenue", "Cost Of Goods Sold")
        gross = _get_row_series(fin, "Gross Profit")
        op_inc = _get_row_series(fin, "Operating Income", "EBIT")
        ni = _get_row_series(fin, "Net Income", "Net Income Common Stockholders")
        if rev is None or len(rev) == 0:
            return out
        d = rev.index[0]
        revenue = abs(_safe_float(rev.get(d)) or 0)
        cogs_val = abs(_safe_float(cogs.get(d)) if cogs is not None and d in cogs.index else 0) or 0
        gross_val = _safe_float(gross.get(d)) if gross is not None and d in gross.index else None
        if gross_val is None and revenue and cogs_val is not None:
            gross_val = revenue - cogs_val
        elif gross_val is None:
            gross_val = revenue
        gross_val = abs(gross_val) if gross_val is not None else 0
        op_inc_val = _safe_float(op_inc.get(d)) if op_inc is not None and d in op_inc.index else None
        op_inc_val = op_inc_val if op_inc_val is not None else 0
        ni_val = _safe_float(ni.get(d)) if ni is not None and d in ni.index else None
        ni_val = ni_val if ni_val is not None else 0
        opex_val = max(0, gross_val - op_inc_val) if (gross_val >= op_inc_val) else 0
        tax_interest_other = max(0, op_inc_val - ni_val) if (op_inc_val - ni_val) > 0 else abs(min(0, op_inc_val - ni_val))
        out["revenue"] = max(revenue, 1)
        out["cogs"] = min(cogs_val, revenue - 1e-6)
        out["gross_profit"] = gross_val
        out["opex"] = opex_val
        out["operating_income"] = op_inc_val
        out["tax_interest_other"] = tax_interest_other
        out["net_income"] = ni_val
        return out
    except Exception:
        return out


def _build_sankey_figure(data: dict) -> "go.Figure":
    """Sankey: Revenue -> COGS + Gross Profit; Gross Profit -> OpEx + OpInc; OpInc -> Tax/Interest/Other + Net Income. Profit=green, Expense=red/grey."""
    if go is None:
        return None
    rev, cogs, gp, opex, opinc, tax_other, ni = (
        data["revenue"], data["cogs"], data["gross_profit"], data["opex"],
        data["operating_income"], data["tax_interest_other"], data["net_income"],
    )
    if rev <= 0:
        return None
    nodes = ["Total Revenue", "Cost of Revenue", "Gross Profit", "Operating Expenses", "Operating Income", "Tax/Interest/Other", "Net Income"]
    node_colors = ["rgba(0,150,80,0.8)", "rgba(180,60,60,0.7)", "rgba(0,150,80,0.8)", "rgba(120,120,120,0.7)", "rgba(0,150,80,0.8)", "rgba(120,120,120,0.7)", "rgba(0,180,90,0.9)"]
    source = [0, 0, 2, 2, 4, 4]
    target = [1, 2, 3, 4, 5, 6]
    value = [cogs, gp, opex, opinc, tax_other, ni]
    value = [max(0, float(v)) for v in value]
    fig = go.Figure(data=[go.Sankey(
        node=dict(label=nodes, color=node_colors, pad=15, thickness=20),
        link=dict(source=source, target=target, value=value),
    )])
    fig.update_layout(title="Income Statement Flow (Latest Year)", height=400, margin=dict(t=40, b=20, l=20, r=20), font=dict(size=12))
    return fig


def sankey_data_from_ai(ai_dict: dict) -> dict:
    """Build Sankey input dict from get_sec_financials_llm result (current_yr). Gross Profit = Revenue - CostOfRevenue; Operating Income = Gross Profit - OperatingExpenses."""
    out = {"revenue": 0, "cogs": 0, "gross_profit": 0, "opex": 0, "operating_income": 0, "tax_interest_other": 0, "net_income": 0}
    cur = (ai_dict or {}).get("current_yr") or {}
    revenue = max(0, (cur.get("Revenue") or 0))
    cogs = max(0, min(cur.get("CostOfRevenue") or 0, revenue - 1e-6))
    gross_profit = revenue - cogs
    opex = max(0, cur.get("OperatingExpenses") or 0)
    operating_income = gross_profit - opex
    net_income = cur.get("NetIncome") or 0
    tax_interest_other = max(0, operating_income - net_income) if operating_income > net_income else abs(min(0, operating_income - net_income))
    out["revenue"] = max(revenue, 1)
    out["cogs"] = cogs
    out["gross_profit"] = gross_profit
    out["opex"] = opex
    out["operating_income"] = operating_income
    out["tax_interest_other"] = tax_interest_other
    out["net_income"] = net_income
    return out


def piotroski_from_ai(ai_dict: dict) -> dict:
    """Piotroski F-Score (0-9) from AI-extracted current_yr vs previous_yr. Returns {score, criteria, used_ttm: True}."""
    out = {"score": 0, "criteria": [], "used_ttm": True}
    cur = (ai_dict or {}).get("current_yr") or {}
    prev = (ai_dict or {}).get("previous_yr") or {}
    if not cur:
        return out
    def v(d, k): return (d.get(k) or 0)
    ni0, ni1 = v(cur, "NetIncome"), v(prev, "NetIncome")
    ocf0 = v(cur, "OperatingCashFlow")
    ta0, ta1 = v(cur, "TotalAssets"), v(prev, "TotalAssets")
    roa0 = (ni0 / ta0 * 100) if ta0 and ta0 != 0 else None
    roa1 = (ni1 / ta1 * 100) if ta1 and ta1 != 0 else None
    c1 = ni0 > 0
    c2 = ocf0 > 0
    c3 = (roa0 is not None and roa1 is not None and roa0 > roa1)
    c4 = ocf0 > ni0
    lt0, lt1 = v(cur, "LongTermDebt"), v(prev, "LongTermDebt")
    c5 = (ta0 and ta1 and (lt0 / ta0) < (lt1 / ta1)) if ta0 and ta1 else False
    ca0, ca1 = v(cur, "CurrentAssets"), v(prev, "CurrentAssets")
    cl0, cl1 = v(cur, "CurrentLiabilities"), v(prev, "CurrentLiabilities")
    cr0 = (ca0 / cl0) if cl0 and cl0 != 0 else None
    cr1 = (ca1 / cl1) if cl1 and cl1 != 0 else None
    c6 = (cr0 is not None and cr1 is not None and cr0 > cr1)
    sh0, sh1 = v(cur, "SharesOutstanding"), v(prev, "SharesOutstanding")
    c7 = (sh0 <= sh1) if (sh0 and sh1) else True
    rev0, rev1 = v(cur, "Revenue"), v(prev, "Revenue")
    gm0 = ((rev0 - v(cur, "CostOfRevenue")) / rev0 * 100) if rev0 and rev0 != 0 else None
    gm1 = ((rev1 - v(prev, "CostOfRevenue")) / rev1 * 100) if rev1 and rev1 != 0 else None
    c8 = (gm0 is not None and gm1 is not None and gm0 > gm1)
    at0 = (rev0 / ta0) if rev0 and ta0 and ta0 != 0 else None
    at1 = (rev1 / ta1) if rev1 and ta1 and ta1 != 0 else None
    c9 = (at0 is not None and at1 is not None and at0 > at1)
    criteria = [
        ("Net Income > 0 (profitability)", c1),
        ("Operating Cash Flow > 0 (cash generative)", c2),
        ("ROA increased vs prior period (improving returns)", c3),
        ("OCF > Net Income (earnings quality, less accruals)", c4),
        ("Leverage decreased: LT Debt/Assets lower (less debt)", c5),
        ("Current Ratio improved (better liquidity)", c6),
        ("No dilution: shares unchanged or lower (no equity raise)", c7),
        ("Gross Margin improved (pricing power)", c8),
        ("Asset Turnover improved (efficiency)", c9),
    ]
    out["score"] = sum(1 for _, p in criteria if p)
    out["criteria"] = criteria
    return out


def radar_metrics_from_ai(ai_dict: dict) -> dict:
    """ROE, Current Ratio, Asset Turnover, Equity Mult, Revenue YoY from AI dict; normalized 0-100 for radar. Equity proxy: TotalAssets - CurrentLiabilities - LongTermDebt."""
    cur = (ai_dict or {}).get("current_yr") or {}
    prev = (ai_dict or {}).get("previous_yr") or {}
    if not cur:
        return {}
    eq0 = (cur.get("TotalAssets") or 0) - (cur.get("CurrentLiabilities") or 0) - (cur.get("LongTermDebt") or 0)
    if eq0 <= 0:
        eq0 = (cur.get("TotalAssets") or 0) * 0.5
    roe = (cur.get("NetIncome") or 0) / eq0 * 100 if eq0 else 0
    ca, cl = cur.get("CurrentAssets") or 0, cur.get("CurrentLiabilities") or 0
    current_ratio = (ca / cl) if cl and cl != 0 else 0
    ta = cur.get("TotalAssets") or 1
    asset_turnover = (cur.get("Revenue") or 0) / ta
    equity_mult = (cur.get("TotalAssets") or 0) / eq0 if eq0 else 0
    rev0, rev1 = cur.get("Revenue") or 0, prev.get("Revenue") or 0
    rev_yoy = ((rev0 - rev1) / rev1 * 100) if rev1 and rev1 != 0 else 0
    return {
        "theta": ["Profitability (ROE)", "Liquidity (Curr.Ratio)", "Efficiency (Asset Turn.)", "Solvency (Equity Mult.)", "Growth (Rev YoY)"],
        "r": _radar_norm(roe, current_ratio, asset_turnover, equity_mult, rev_yoy),
        "labels": ["Profitability (ROE)", "Liquidity (Curr.Ratio)", "Efficiency (Asset Turn.)", "Solvency (Equity Mult.)", "Growth (Rev YoY)"],
    }


@st.cache_data(ttl=300)
def get_radar_metrics_normalized(ticker: str) -> dict:
    """ROE, Current Ratio, Asset Turnover, Equity Mult, Revenue YoY. Normalized to 0-100 for radar. Returns {theta: [...], r: [...], labels: [...]} or empty."""
    if not ticker:
        return {}
    q = get_dupont_altman_redflags_yoy(ticker)
    if not q:
        return {}
    dupont_df = q.get("dupont")
    if dupont_df is None or dupont_df.empty or len(dupont_df) < 2:
        return {}
    row0 = dupont_df.iloc[0]
    row1 = dupont_df.iloc[1]
    roe = row0.get("ROE %") or 0
    cr = row0.get("Current Ratio") or 0
    at = row0.get("Asset Turnover") or 0
    em = row0.get("Equity Mult.") or 0
    rev0 = dupont_df["Revenue"].iloc[0] if "Revenue" in dupont_df.columns else None
    rev1 = dupont_df["Revenue"].iloc[1] if "Revenue" in dupont_df.columns else None
    rev_yoy = ((rev0 - rev1) / rev1 * 100) if (rev0 and rev1 and rev1 != 0) else 0
    def norm_roe(x):
        if x is None: return 50
        return min(100, max(0, (x + 10) / 40 * 100))
    def norm_cr(x):
        if x is None: return 50
        return min(100, max(0, x / 3 * 100))
    def norm_at(x):
        if x is None: return 50
        return min(100, max(0, x * 50))
    def norm_em(x):
        if x is None: return 50
        return min(100, max(0, (x - 0.5) / 2.5 * 100))
    def norm_yoy(x):
        if x is None: return 50
        return min(100, max(0, (x + 20) / 50 * 100))
    return {
        "theta": ["Profitability (ROE)", "Liquidity (Curr.Ratio)", "Efficiency (Asset Turn.)", "Solvency (Equity Mult.)", "Growth (Rev YoY)"],
        "r": [norm_roe(roe), norm_cr(cr), norm_at(at), norm_em(em), norm_yoy(rev_yoy)],
        "labels": ["Profitability (ROE)", "Liquidity (Curr.Ratio)", "Efficiency (Asset Turn.)", "Solvency (Equity Mult.)", "Growth (Rev YoY)"],
    }


def _build_radar_figure(ticker: str) -> "go.Figure":
    """Plotly line_polar radar chart; fill with translucent color."""
    if go is None:
        return None
    data = get_radar_metrics_normalized(ticker)
    if not data or not data.get("r"):
        return None
    theta = data["theta"] + [data["theta"][0]]
    r = data["r"] + [data["r"][0]]
    fig = go.Figure(data=go.Scatterpolar(r=r, theta=theta, fill="toself", fillcolor="rgba(30, 120, 200, 0.4)", line=dict(color="rgb(30,120,200)", width=2)))
    fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 100]), angularaxis=dict(tickfont=dict(size=11))), title="Financial Health Radar", height=400, showlegend=False)
    return fig


def _build_radar_figure_from_metrics(metrics: dict) -> "go.Figure":
    """Build radar chart from precomputed metrics dict (theta, r, labels). Used for SEC Item 8 AI path."""
    if go is None or not metrics or not metrics.get("r"):
        return None
    theta = metrics["theta"] + [metrics["theta"][0]]
    r = metrics["r"] + [metrics["r"][0]]
    fig = go.Figure(data=go.Scatterpolar(r=r, theta=theta, fill="toself", fillcolor="rgba(30, 120, 200, 0.4)", line=dict(color="rgb(30,120,200)", width=2)))
    fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 100]), angularaxis=dict(tickfont=dict(size=11))), title="Financial Health Radar (from 10-K Item 8)", height=400, showlegend=False)
    return fig


def _radar_norm(roe_pct, current_ratio, asset_turnover, equity_mult, rev_yoy_pct):
    """Normalize 5 raw metrics to 0–100 for radar (same logic as get_radar_metrics_normalized)."""
    def n_roe(x): return min(100, max(0, (x + 10) / 40 * 100)) if x is not None else 50
    def n_cr(x): return min(100, max(0, x / 3 * 100)) if x is not None else 50
    def n_at(x): return min(100, max(0, x * 50)) if x is not None else 50
    def n_em(x): return min(100, max(0, (x - 0.5) / 2.5 * 100)) if x is not None else 50
    def n_yoy(x): return min(100, max(0, (x + 20) / 50 * 100)) if x is not None else 50
    return [n_roe(roe_pct), n_cr(current_ratio), n_at(asset_turnover), n_em(equity_mult), n_yoy(rev_yoy_pct)]


def _build_radar_from_manual(roe_pct, current_ratio, asset_turnover, equity_mult, rev_yoy_pct) -> "go.Figure":
    """Build radar chart from 5 manually entered ratios (fallback when ticker data missing)."""
    if go is None:
        return None
    theta = ["Profitability (ROE)", "Liquidity (Curr.Ratio)", "Efficiency (Asset Turn.)", "Solvency (Equity Mult.)", "Growth (Rev YoY)"]
    r = _radar_norm(roe_pct, current_ratio, asset_turnover, equity_mult, rev_yoy_pct)
    theta_closed = theta + [theta[0]]
    r_closed = r + [r[0]]
    fig = go.Figure(data=go.Scatterpolar(r=r_closed, theta=theta_closed, fill="toself", fillcolor="rgba(30, 120, 200, 0.4)", line=dict(color="rgb(30,120,200)", width=2)))
    fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 100]), angularaxis=dict(tickfont=dict(size=11))), title="Financial Health Radar (Manual)", height=400, showlegend=False)
    return fig


@st.cache_data(ttl=300)
def get_piotroski_fscore(ticker: str) -> dict:
    """Piotroski F-Score (0-9) from last 2 periods. Uses yahooquery then yfinance with TTM fallback. Returns score + criteria + used_ttm."""
    out = {"score": 0, "criteria": [], "used_ttm": False}
    fin, bal, cf = _get_annual_financials_balance_cashflow(ticker)
    if fin is None or fin.empty or bal is None or bal.empty:
        return out
    if cf is None or cf.empty:
        cf = pd.DataFrame()
    try:
        ncol = min(2, len(fin.columns))
        rev = _get_row_series(fin, "Total Revenue", "Revenue")
        ni = _get_row_series(fin, "Net Income", "Net Income Common Stockholders")
        gross = _get_row_series(fin, "Gross Profit")
        ta = _get_row_series(bal, "Total Assets")
        lt_debt = _get_row_series(bal, "Long Term Debt")
        ca = _get_row_series(bal, "Current Assets")
        cl = _get_row_series(bal, "Current Liabilities")
        ocf = _get_row_series(cf, "Operating Cash Flow", "Cash From Operating Activities") if not cf.empty else None
        shares = _get_row_series(bal, "Share Issued") or _get_row_series(bal, "Ordinary Shares Number")
        if shares is None and yf:
            t = yf.Ticker(ticker.upper())
            info = getattr(t, "info", None) or {}
            sh_info = info.get("sharesOutstanding") or info.get("Shares Outstanding")
            if sh_info is not None:
                try:
                    sh_float = float(sh_info)
                    shares = pd.Series([sh_float] * ncol, index=fin.columns[:ncol])
                except (TypeError, ValueError):
                    pass
        def v0(s):
            if s is None or len(s) == 0:
                return None
            x = _safe_float(s.iloc[0])
            return x if (x is not None and x == x and not (isinstance(x, float) and pd.isna(x))) else None
        def v1(s):
            if s is None or len(s) < 2:
                return None
            x = _safe_float(s.iloc[1])
            return x if (x is not None and x == x and not (isinstance(x, float) and pd.isna(x))) else None
        ni0, ni1 = v0(ni), v1(ni)
        ocf0 = v0(ocf) if ocf is not None else None
        ta0, ta1 = v0(ta), v1(ta)
        roa0 = (ni0 / ta0 * 100) if (ni0 is not None and ta0 is not None and ta0 != 0) else None
        roa1 = (ni1 / ta1 * 100) if (ni1 is not None and ta1 is not None and ta1 != 0) else None
        c1 = (ni0 is not None and ni0 > 0)
        c2 = (ocf0 is not None and ocf0 > 0)
        c3 = (roa0 is not None and roa1 is not None and roa0 > roa1)
        c4 = (ocf0 is not None and ni0 is not None and ocf0 > ni0)
        lt0 = v0(lt_debt) or 0
        lt1 = v1(lt_debt) or 0
        c5 = (ta0 is not None and ta0 != 0 and ta1 is not None and ta1 != 0 and (lt0 / ta0) < (lt1 / ta1))
        cl0, cl1 = v0(cl), v1(cl)
        ca0, ca1 = v0(ca), v1(ca)
        cr0 = (ca0 / cl0) if (ca0 is not None and cl0 is not None and cl0 != 0) else None
        cr1 = (ca1 / cl1) if (ca1 is not None and cl1 is not None and cl1 != 0) else None
        c6 = (cr0 is not None and cr1 is not None and cr0 > cr1)
        sh0, sh1 = v0(shares), v1(shares)
        c7 = (sh0 is not None and sh1 is not None and sh0 <= sh1) if (sh0 is not None and sh1 is not None) else True
        rev0, rev1 = v0(rev), v1(rev)
        gm0 = (v0(gross) / rev0 * 100) if (gross is not None and rev0 is not None and rev0 != 0) else None
        gm1 = (v1(gross) / rev1 * 100) if (gross is not None and rev1 is not None and rev1 != 0) else None
        c8 = (gm0 is not None and gm1 is not None and gm0 > gm1)
        at0 = (rev0 / ta0) if (rev0 is not None and ta0 is not None and ta0 != 0) else None
        at1 = (rev1 / ta1) if (rev1 is not None and ta1 is not None and ta1 != 0) else None
        c9 = (at0 is not None and at1 is not None and at0 > at1)
        criteria = [
            ("Net Income > 0 (profitability)", c1),
            ("Operating Cash Flow > 0 (cash generative)", c2),
            ("ROA increased vs prior period (improving returns)", c3),
            ("OCF > Net Income (earnings quality, less accruals)", c4),
            ("Leverage decreased: LT Debt/Assets lower (less debt)", c5),
            ("Current Ratio improved (better liquidity)", c6),
            ("No dilution: shares unchanged or lower (no equity raise)", c7),
            ("Gross Margin improved (pricing power)", c8),
            ("Asset Turnover improved (efficiency)", c9),
        ]
        score = sum(1 for _, p in criteria if p)
        out["score"] = score
        out["criteria"] = criteria
        out["used_ttm"] = bool(fin is not None and hasattr(fin, "columns") and len(fin.columns) > 0 and any(str(c).startswith("TTM") for c in fin.columns))
        return out
    except Exception:
        out["used_ttm"] = False
        return out


@st.cache_data(ttl=300)
def get_sector_specific_metrics(ticker: str, sector: str) -> dict:
    """Technology: Rule of 40, R&D % revenue. Retail/Consumer: Inventory Turnover, Operating Margin. Financials: ROE, ROA."""
    if not yf:
        return {}
    try:
        t = yf.Ticker(ticker.upper())
        info = t.info or {}
        fin = t.financials
        bal = t.balance_sheet
        if fin is None or fin.empty:
            fin = getattr(t, "quarterly_financials", None)
            if fin is not None and not fin.empty:
                fin = fin.iloc[:, :4].sum(axis=1).to_frame()
        if bal is None or bal.empty:
            bal = getattr(t, "quarterly_balance_sheet", None)
        out = {}
        sector_lower = (sector or "").lower()
        if "technology" in sector_lower or "software" in sector_lower or "tech" in sector_lower:
            rev = _get_row_series(fin, "Total Revenue", "Revenue", "Net Revenue")
            ocf = _get_row_series(t.cashflow or getattr(t, "quarterly_cashflow", None), "Operating Cash Flow", "Cash From Operating Activities")
            capx = _get_row_series(t.cashflow or getattr(t, "quarterly_cashflow", None), "Capital Expenditure", "Capital Expenditures")
            rd = _get_row_series(fin, "Research And Development", "Research And Development Expense")
            if rev is not None and len(rev) > 0:
                r0 = _safe_float(rev.iloc[0])
                if ocf is not None and len(ocf) > 0 and capx is not None and len(capx) > 0:
                    fcf = _safe_float(ocf.iloc[0]) - _safe_float(capx.iloc[0])
                    out["FCF Margin %"] = round(fcf / r0 * 100, 2) if r0 and fcf is not None else None
                if rd is not None and len(rd) > 0:
                    out["R&D % of Revenue"] = round(_safe_float(rd.iloc[0]) / r0 * 100, 2) if r0 else None
                rev_growth = None
                if rev is not None and len(rev) >= 2:
                    cur, prev = _safe_float(rev.iloc[0]), _safe_float(rev.iloc[1])
                    if prev and prev != 0:
                        rev_growth = (cur - prev) / prev * 100
                if rev_growth is not None and "FCF Margin %" in out and out["FCF Margin %"] is not None:
                    out["Rule of 40 (Rev Growth + FCF Margin)"] = round(rev_growth + out["FCF Margin %"], 1)
        if "consumer" in sector_lower or "retail" in sector_lower or "cyclical" in sector_lower:
            inv = _get_row_series(bal, "Inventory", "Total Inventory")
            cogs = _get_row_series(fin, "Cost Of Revenue", "Cost Of Goods Sold", "Cost of Goods Sold")
            rev = _get_row_series(fin, "Total Revenue", "Revenue", "Net Revenue")
            op_inc = _get_row_series(fin, "Operating Income", "EBIT")
            if inv is not None and len(inv) > 0 and cogs is not None and len(cogs) > 0:
                inv0 = _safe_float(inv.iloc[0])
                cogs0 = _safe_float(cogs.iloc[0])
                out["Inventory Turnover"] = round(cogs0 / inv0, 2) if inv0 else None
            if rev is not None and len(rev) > 0 and op_inc is not None and len(op_inc) > 0:
                r0 = _safe_float(rev.iloc[0])
                op0 = _safe_float(op_inc.iloc[0])
                out["Operating Margin %"] = round(op0 / r0 * 100, 2) if r0 else None
        if "financial" in sector_lower or "bank" in sector_lower or "insurance" in sector_lower:
            ni = _get_row_series(fin, "Net Income", "Net Income Common Stockholders")
            te = _get_row_series(bal, "Total Stockholder Equity", "Stockholders Equity", "Total Equity Gross Minority Interest")
            ta = _get_row_series(bal, "Total Assets")
            if ni is not None and te is not None and len(ni) > 0 and len(te) > 0:
                te0 = _safe_float(te.iloc[0])
                ni0 = _safe_float(ni.iloc[0])
                out["ROE %"] = round(ni0 / te0 * 100, 2) if te0 else None
            if ni is not None and ta is not None and len(ni) > 0 and len(ta) > 0:
                ta0 = _safe_float(ta.iloc[0])
                ni0 = _safe_float(ni.iloc[0])
                out["ROA %"] = round(ni0 / ta0 * 100, 2) if ta0 else None
        return out
    except Exception:
        return {}


# ---------- Streamlit UI ----------
st.set_page_config(page_title="Financial Analysis Dashboard", layout="wide", initial_sidebar_state="expanded")

# Professional styling
st.markdown("""
<style>
    .stTabs [data-baseweb="tab-list"] { gap: 8px; }
    .stTabs [data-baseweb="tab"] { padding: 12px 24px; font-weight: 600; }
    div[data-testid="stMetricValue"] { font-size: 1.4rem; }
    .block-container { padding-top: 1.5rem; max-width: 1200px; }
</style>
""", unsafe_allow_html=True)

st.title("All-in-One Financial Analysis Dashboard")
st.caption("Hybrid: Gemini for qualitative (10-K MD&A & Risks); yahooquery + yfinance for quantitative (DCF, Comps). No API key needed for fundamentals.")

with st.sidebar:
    st.header("Settings")
    _prefs = _load_prefs()
    _default_key = _prefs.get("google_api_key") or os.environ.get("GOOGLE_API_KEY", "")
    _default_email = _prefs.get("sec_email") or os.environ.get("SEC_EDGAR_EMAIL", "")
    google_api_key = st.text_input(
        "Google API Key (Gemini)",
        type="password",
        value=_default_key,
        help="Required for Tab 1 (10-K insights).",
        key="input_google_api_key",
    )
    sec_email = st.text_input(
        "SEC EDGAR Email",
        value=_default_email,
        help="Required for 10-K download.",
        key="input_sec_email",
    )
    remember_me = st.checkbox(
        "Remember API key & email (save locally)",
        value=bool(_prefs),
        help="Store in .app_prefs.json in this project. Uncheck to clear and stop saving.",
        key="remember_me",
    )
    if remember_me and (google_api_key or sec_email):
        _save_prefs(google_api_key, sec_email)
    elif not remember_me and _PREFS_PATH.exists():
        try:
            _PREFS_PATH.unlink()
        except Exception:
            pass
    st.markdown("**🔍 Company search**")
    search_query = st.text_input(
        "Search Company Name (e.g., Apple, 삼성, Mitsubishi)",
        value=st.session_state.get("company_search_input", ""),
        key="company_search_input",
        placeholder="e.g. Apple, 삼성, Mitsubishi",
    )
    if st.button("Search Company", key="search_company_btn"):
        query = (search_query or "").strip()
        if not query:
            st.warning("Enter a company name to search.")
        elif yq_search is None:
            st.warning("yahooquery is not installed; search is unavailable.")
        else:
            try:
                raw_results = yq_search(query)
                if not isinstance(raw_results, dict):
                    raw_results = {}
                quotes = raw_results.get("quotes", []) or []
                skip_types = ("INDEX", "MUTUALFUND")
                quotes = [
                    q for q in quotes
                    if q.get("symbol") and q.get("shortname")
                    and (q.get("quoteType") or "EQUITY") not in skip_types
                ]
                if not quotes:
                    st.session_state["company_search_options"] = []
                    st.session_state["company_search_symbols"] = []
                    st.warning("No valid equities found. Try typing the English name (e.g., 'Samsung' instead of '삼성').")
                else:
                    options = []
                    symbols = []
                    for q in quotes[:50]:
                        sym = (q.get("symbol") or "").strip()
                        options.append(f"[{q.get('exchange', 'N/A')}] {q.get('symbol')} - {q.get('shortname', 'Unknown')}")
                        symbols.append(sym)
                    st.session_state["company_search_options"] = options
                    st.session_state["company_search_symbols"] = symbols
                    st.session_state["ticker"] = symbols[0]
                    st.success(f"Found {len(options)} result(s). Select below.")
            except Exception:
                st.warning("No valid equities found. Try typing the English name (e.g., 'Samsung' instead of '삼성').")
                st.session_state["company_search_options"] = []
                st.session_state["company_search_symbols"] = []

    search_options = st.session_state.get("company_search_options") or []
    search_symbols = st.session_state.get("company_search_symbols") or []
    placeholder = "— Click the search button above —"
    options_for_select = [placeholder] if not search_options else search_options
    current_ticker = st.session_state.get("ticker", "NVDA")
    default_idx = 0
    if search_symbols and current_ticker:
        for i, sym in enumerate(search_symbols):
            if sym == current_ticker:
                default_idx = i
                break
    selected_option = st.selectbox(
        "Select company (ticker - name)",
        options=options_for_select,
        index=0 if not search_options else min(default_idx, len(search_options) - 1),
        key="company_select",
    )
    if search_options and selected_option and selected_option != placeholder and " - " in selected_option:
        first_part = selected_option.split(" - ", 1)[0].strip()
        sym = first_part.split("]", 1)[-1].strip() if "]" in first_part else first_part
        st.session_state["ticker"] = sym
    ticker = st.session_state.get("ticker") or (search_symbols[0] if search_symbols else "NVDA")
    st.session_state["google_api_key"] = google_api_key
    st.session_state["sec_email"] = sec_email
    st.session_state["ticker"] = ticker
    st.session_state["market"] = infer_market_from_ticker(ticker)
    st.caption("Search by name (any language), then select. Ticker suffix is set automatically.")

tab1, tab2, tab3 = st.tabs(["10-K & MD&A Insights", "3-Scenario DCF Valuation", "Industry Analysis & Comps"])

# ----- Tab 1: Qualitative (MD&A) + Quantitative (DuPont, Altman Z, Red Flags, YoY) -----
with tab1:
    market = st.session_state.get("market") or MARKET_OPTIONS[0]
    quant_ticker = get_global_ticker(ticker, market) if ticker else ""
    st.subheader("10-K & MD&A Insights — Qualitative and Quantitative")
    if ticker:
        si = get_sector_industry(quant_ticker)
        sector, industry = si.get("sector", "N/A"), si.get("industry", "N/A")
        st.caption(f"Sector: **{sector}**  ·  Industry: **{industry}**" + (f"  ·  Ticker: **{quant_ticker}**" if quant_ticker != ticker else ""))
    if ticker:
        google_api_key = (st.session_state.get("google_api_key") or "").strip()
        sec_email = (st.session_state.get("sec_email") or "").strip()
        ai_data = {}
        if market and "US" in market and google_api_key and sec_email:
            with st.spinner("SEC 10-K 원본에서 재무제표 데이터를 해독하여 그래프를 생성 중입니다... (약 30~60초 소요)"):
                sections, _ = get_10k_sections(ticker, sec_email)
                item8 = (sections or {}).get("item8") or ""
                if item8.strip():
                    ai_data = get_sec_financials_llm(google_api_key, item8, ticker)
        q = get_dupont_altman_redflags_yoy(quant_ticker)
        dupont_df = (q or {}).get("dupont") if q else None
        if q or ai_data:
            st.markdown("---")
            st.markdown("#### 📊 Financial Health (Tables & Charts)")
            c1, c2 = st.columns(2)
            with c1:
                if ai_data and ai_data.get("current_yr"):
                    sankey_data = sankey_data_from_ai(ai_data)
                else:
                    sankey_data = get_income_statement_sankey_data(quant_ticker)
                if sankey_data.get("revenue", 0) > 0:
                    fig_sankey = _build_sankey_figure(sankey_data)
                    if fig_sankey is not None:
                        st.plotly_chart(fig_sankey, use_container_width=True)
                else:
                    st.caption("Income Statement flow: data not available.")
            with c2:
                if ai_data and ai_data.get("current_yr"):
                    radar_metrics = radar_metrics_from_ai(ai_data)
                    fig_radar = _build_radar_figure_from_metrics(radar_metrics) if radar_metrics else None
                else:
                    fig_radar = _build_radar_figure(quant_ticker)
                if fig_radar is not None:
                    st.plotly_chart(fig_radar, use_container_width=True)
                else:
                    st.caption("Financial radar: need 2+ years of data.")
                    with st.expander("Manual Data Entry (Radar Chart Fallback)", expanded=False):
                        st.caption("Enter 5 key ratios to plot a custom radar. ROE %, Current Ratio, Asset Turnover, Equity Mult., Revenue YoY %.")
                        roe_man = st.number_input("ROE %", value=15.0, min_value=-50.0, max_value=100.0, step=1.0, key="radar_roe")
                        cr_man = st.number_input("Current Ratio", value=1.5, min_value=0.0, max_value=10.0, step=0.1, key="radar_cr")
                        at_man = st.number_input("Asset Turnover", value=0.8, min_value=0.0, max_value=5.0, step=0.1, key="radar_at")
                        em_man = st.number_input("Equity Mult.", value=2.0, min_value=0.5, max_value=10.0, step=0.1, key="radar_em")
                        yoy_man = st.number_input("Revenue YoY %", value=10.0, min_value=-50.0, max_value=200.0, step=1.0, key="radar_yoy")
                        if st.button("Plot Radar", key="radar_plot_btn"):
                            fig_man = _build_radar_from_manual(roe_man, cr_man, at_man, em_man, yoy_man)
                            if fig_man is not None:
                                st.session_state["radar_manual_fig"] = fig_man
                        if st.session_state.get("radar_manual_fig") is not None:
                            st.plotly_chart(st.session_state["radar_manual_fig"], use_container_width=True)
                    with st.expander("Debug: Raw YahooQuery Data", expanded=False):
                        if YQTicker and quant_ticker:
                            try:
                                yq_ticker = YQTicker(quant_ticker.upper())
                                inc_raw = yq_ticker.income_statement(trailing=False)
                                bal_raw = yq_ticker.balance_sheet(trailing=False)
                                if inc_raw is not None and not inc_raw.empty:
                                    st.caption("Income statement (last 2 periods) — check column names for mapping.")
                                    st.dataframe(inc_raw.tail(2), use_container_width=True, hide_index=True)
                                else:
                                    st.caption("Income statement: no data.")
                                if bal_raw is not None and not bal_raw.empty:
                                    st.caption("Balance sheet (last 2 periods) — check column names for mapping.")
                                    st.dataframe(bal_raw.tail(2), use_container_width=True, hide_index=True)
                                else:
                                    st.caption("Balance sheet: no data.")
                            except Exception as e:
                                st.error(f"YahooQuery debug failed: {e}")
                        else:
                            st.caption("YahooQuery not available or no ticker selected.")
            if ai_data and ai_data.get("current_yr"):
                piot = piotroski_from_ai(ai_data)
            else:
                piot = get_piotroski_fscore(quant_ticker)
            st.markdown("**Piotroski F-Score (9-point checklist)**")
            score = piot.get("score", 0)
            legend = "**Score 8–9: Excellent** · 4–7: Average · 0–3: High Risk"
            st.metric("F-Score", f"{score} / 9", legend)
            if ai_data and ai_data.get("current_yr"):
                st.caption("*(from SEC 10-K Item 8)*")
            elif piot.get("used_ttm"):
                st.caption("*(Estimated via TTM Data)*")
            st.caption("✅ = Good (passes criterion). ❌ = Fails criterion.")
            criteria = piot.get("criteria", [])
            if criteria:
                cols = st.columns(3)
                for i, (label, passed) in enumerate(criteria):
                    with cols[i % 3]:
                        st.caption(("✅ " if passed else "❌ ") + label)
            az = (q or {}).get("altman_z")
            if az is not None:
                st.caption(f"**Altman Z-Score:** {az} (Safe > 2.99 · Grey 1.81–2.99 · Distress < 1.81)")
            red_flags = (q or {}).get("red_flags") or []
            if red_flags:
                for rf in red_flags:
                    val = rf.get("value")
                    val_str = "N/A" if (val is None or (isinstance(val, float) and (pd.isna(val) or val != val))) else val
                    st.warning(f"**{rf.get('metric')}:** {val_str} (threshold: {rf.get('threshold')})")
            elif dupont_df is not None and not dupont_df.empty:
                st.success("No red flags (Current Ratio ≥ 1.0, Interest Coverage ≥ 1.5).")
            sector_metrics = get_sector_specific_metrics(quant_ticker, sector) if quant_ticker else {}
            if sector_metrics:
                st.markdown("**Sector-specific metrics**")
                cols = st.columns(min(len(sector_metrics), 4))
                for i, (k, v) in enumerate(sector_metrics.items()):
                    with cols[i % len(cols)]:
                        disp = f"{v}" if v is not None else "N/A"
                        st.metric(k, disp, None)
            def _style_change_column(df: pd.DataFrame):
                """Green for improvement (+), red for decline (-) in Change column."""
                change_col = "Change (%)" if "Change (%)" in df.columns else "Change"
                if change_col not in df.columns or df.empty:
                    return df.style
                def _cell_style(v):
                    if v is None or (isinstance(v, float) and pd.isna(v)):
                        return ""
                    s = str(v).strip()
                    if s == "—":
                        return ""
                    if s.startswith("+") or "↑" in s:
                        return "background-color: #d4edda; color: #155724"
                    if s.startswith("-") or "↓" in s:
                        return "background-color: #f8d7da; color: #721c24"
                    return ""
                return df.style.apply(lambda col: [_cell_style(v) for v in col], subset=[change_col])
            yoy_list = (q or {}).get("yoy") or []
            if yoy_list:
                st.markdown("**YoY ratio changes**")
                rows_yoy = []
                for item in yoy_list:
                    cur = item.get("Latest")
                    chg_pp = item.get("YoY (pp)")
                    chg_pct = item.get("YoY %")
                    if chg_pp is not None:
                        chg_str = f"{chg_pp:+.1f}%"
                    elif chg_pct is not None:
                        chg_str = f"{chg_pct:+.1f}%"
                    else:
                        chg_str = "—"
                    status = "↑" if (chg_pp is not None and chg_pp > 0) or (chg_pct is not None and chg_pct > 0) else ("↓" if (chg_pp is not None and chg_pp < 0) or (chg_pct is not None and chg_pct < 0) else "—")
                    rows_yoy.append({"Metric": item.get("Ratio"), "Current Value": cur, "Change (%)": chg_str, "Status": status})
                if rows_yoy:
                    df_yoy = pd.DataFrame(rows_yoy)
                    st.dataframe(_style_change_column(df_yoy), use_container_width=True, hide_index=True)
            st.markdown("**Quarter ratio changes**")
            qmom = get_quarterly_momentum(quant_ticker)
            qoq_rows = get_quarterly_ratio_changes(quant_ticker)
            qoq_r, qoq_n = qmom.get("qoq_revenue_pct"), qmom.get("qoq_ni_pct")
            build = []
            if qoq_r is not None:
                build.append({"Metric": "Revenue", "Current Value": "—", "Change (%)": f"{qoq_r:+.1f}%", "Status": "↑" if qoq_r > 0 else "↓"})
            if qoq_n is not None:
                build.append({"Metric": "Net Income", "Current Value": "—", "Change (%)": f"{qoq_n:+.1f}%", "Status": "↑" if qoq_n > 0 else "↓"})
            for r in qoq_rows:
                r_copy = dict(r)
                if "Change" in r_copy and "Change (%)" not in r_copy:
                    r_copy["Change (%)"] = r_copy.pop("Change", "—")
                if "Trend" in r_copy:
                    r_copy["Status"] = r_copy.pop("Trend", "—")
                build.append(r_copy)
            if build:
                df_q = pd.DataFrame(build)
                if "Change" in df_q.columns and "Change (%)" not in df_q.columns:
                    df_q = df_q.rename(columns={"Change": "Change (%)"})
                if "Trend" in df_q.columns:
                    df_q = df_q.rename(columns={"Trend": "Status"})
                st.dataframe(_style_change_column(df_q), use_container_width=True, hide_index=True)
            elif not qmom.get("df") or qmom["df"].empty:
                st.caption("Quarterly data not available for this ticker.")
        else:
            st.info("Quantitative data not available for this ticker.")
    st.markdown("---")
    st.markdown("#### 🔍 Deep-Dive Analysis (AI)")
    st.caption("10-K sections are cached in **data/**; repeat runs use cache for instant AI analysis. First run may take 20–60 s to fetch 10-K; Gemini then streams in ~5–10 s.")
    if not ticker:
        st.caption("Enter a ticker in the sidebar to enable analysis.")
    else:
        api_ok = bool(st.session_state.get("google_api_key"))
        email_ok = bool(st.session_state.get("sec_email"))
        err_msg = []
        if not api_ok:
            err_msg.append("Google API Key")
        if not email_ok:
            err_msg.append("SEC EDGAR Email")
        if err_msg:
            st.caption(f"Set **{' and '.join(err_msg)}** in the sidebar to run analysis.")
        col_a, col_b = st.columns(2)
        is_us = market and "US" in market
        is_korea = market and ("Korea" in market or "KOSPI" in market or "KOSDAQ" in market)
        is_japan_uk = market and ("Japan" in market or "Nikkei" in market or "UK" in market or "LSE" in market)
        # --- Button A: Management Strategy ---
        with col_a:
            if st.button("Analyze Management Strategy (MD&A)", key="run_mda_strategy"):
                if is_korea:
                    st.warning("DART API integration for Korean MD&A is currently under construction. Please check back in Phase 2.")
                elif is_japan_uk:
                    st.warning("EDINET/LSE document parsing is currently under development.")
                elif not api_ok or not email_ok:
                    st.error("Set API Key and SEC Email in the sidebar.")
                else:
                    try:
                        with st.status("Loading 10-K (cache or download)...", expanded=True) as status:
                            sections, _ = get_10k_sections(ticker, st.session_state["sec_email"])
                            si = get_sector_industry(quant_ticker)
                            status.update(label="10-K loaded. Calling Gemini…", state="running")

                        # Stream OUTSIDE the status box so user sees text as it arrives
                        st.markdown("### Management Strategy (Item 7)")
                        st.caption("Streaming from Gemini (first words in ~5–10 sec, then flows in real time).")
                        stream_gen = get_gemini_item7_strategy_stream(
                            st.session_state["google_api_key"],
                            sections.get("item7") or "",
                            ticker,
                            si.get("sector") or "N/A",
                            si.get("industry") or "N/A",
                        )
                        # write_stream returns the full concatenated string after it finishes streaming
                        full_response = st.write_stream(stream_gen)

                        st.session_state["mda_strategy_result"] = full_response
                        st.session_state["mda_strategy_ticker"] = ticker
                        st.session_state["mda_strategy_error"] = None
                    except Exception as e:
                        st.session_state["mda_strategy_error"] = str(e)
                        st.error(f"Strategy analysis failed: {str(e)}")
        # --- Button B: Risk Factors & Forensic ---
        with col_b:
            if st.button("Analyze Risk Factors (Item 1A)", key="run_mda_risk"):
                if is_korea:
                    st.warning("DART API integration for Korean MD&A is currently under construction. Please check back in Phase 2.")
                elif is_japan_uk:
                    st.warning("EDINET/LSE document parsing is currently under development.")
                elif not api_ok or not email_ok:
                    st.error("Set API Key and SEC Email in the sidebar.")
                else:
                    try:
                        with st.status("Loading 10-K (cache or download)...", expanded=True) as status:
                            sections, _ = get_10k_sections(ticker, st.session_state["sec_email"])
                            status.update(label="10-K loaded. Running forensic audit…", state="running")

                            # Run forensic silently IN THE BACKGROUND first
                            forensic = _gemini_forensic_audit(
                                st.session_state["google_api_key"],
                                sections.get("item3") or "",
                                sections.get("item9a") or "",
                                ticker,
                            )
                            status.update(label="Done.", state="complete")
                        # Stream the risk factors OUTSIDE the status box
                        st.markdown("### Risk Factors (Item 1A)")
                        st.caption("Streaming from Gemini (first words in ~5–10 sec, then flows in real time).")
                        stream_gen = get_gemini_item1a_risks_stream(
                            st.session_state["google_api_key"],
                            sections.get("item1a") or "",
                            ticker,
                        )
                        risk_response = st.write_stream(stream_gen)

                        # Combine both for the final result
                        final_out = risk_response
                        if forensic and forensic.strip():
                            st.markdown("### Forensic Audit (Item 3 & 9A)")
                            st.markdown(forensic.strip())
                            final_out += f"\n\n---\n\n### Forensic Audit (Item 3 & 9A)\n\n{forensic.strip()}"

                        st.session_state["mda_risk_result"] = final_out
                        st.session_state["mda_risk_ticker"] = ticker
                        st.session_state["mda_risk_error"] = None
                    except Exception as e:
                        st.session_state["mda_risk_error"] = str(e)
                        st.error(f"Risk analysis failed: {str(e)}")
        # --- Display Saved Results if User Switches Tabs ---
        st.markdown("---")
        if st.session_state.get("mda_strategy_ticker") == ticker:
            if st.session_state.get("mda_strategy_error"):
                st.error("Strategy Error: " + st.session_state["mda_strategy_error"])
            elif st.session_state.get("mda_strategy_result"):
                with st.expander("View Previous Strategy Analysis", expanded=True):
                    st.markdown(st.session_state["mda_strategy_result"])
        if st.session_state.get("mda_risk_ticker") == ticker:
            if st.session_state.get("mda_risk_error"):
                st.error("Risk Error: " + st.session_state["mda_risk_error"])
            elif st.session_state.get("mda_risk_result"):
                with st.expander("View Previous Risk & Forensic Analysis", expanded=True):
                    st.markdown(st.session_state["mda_risk_result"])

# ----- Tab 2: 5-Year Trend + 3-Scenario DCF -----
with tab2:
    market_t2 = st.session_state.get("market") or MARKET_OPTIONS[0]
    quant_ticker_t2 = get_global_ticker(ticker, market_t2) if ticker else ""
    st.subheader("5-Year Financial Trend & DCF Valuation")
    if ticker:
        si_t2 = get_sector_industry(quant_ticker_t2)
        sector_t2 = (si_t2.get("sector") or "").lower()
        is_financial = "financial" in sector_t2 or "bank" in sector_t2 or "insurance" in sector_t2
    else:
        is_financial = False
    df_trend = get_5yr_financial_trend(quant_ticker_t2) if quant_ticker_t2 else pd.DataFrame()
    if not df_trend.empty and len(df_trend) >= 1:
        st.markdown("#### Key metrics (YoY % change)")
        latest = df_trend.iloc[0]
        prev = df_trend.iloc[1] if len(df_trend) >= 2 else None
        def _yoy_pct(cur, prev_val):
            if prev_val is None or cur is None or prev_val == 0:
                return None
            return (cur - prev_val) / abs(prev_val) * 100
        rev_yoy = _yoy_pct(latest.get("Revenue"), prev.get("Revenue") if prev is not None else None)
        ni_yoy = _yoy_pct(latest.get("Net Income"), prev.get("Net Income") if prev is not None else None)
        om_prev = prev.get("Operating Margin %") if prev is not None else None
        om_cur = latest.get("Operating Margin %")
        om_yoy = (om_cur - om_prev) if (om_cur is not None and om_prev is not None) else None
        fcf_yoy = _yoy_pct(latest.get("FCF"), prev.get("FCF") if prev is not None else None)
        m1, m2, m3, m4 = st.columns(4)
        rev_val = latest.get("Revenue")
        m1.metric("Revenue (latest yr)", f"${rev_val/1e9:.2f}B" if rev_val and rev_val >= 1e9 else (f"${rev_val/1e6:.0f}M" if rev_val else "—"), f"{rev_yoy:+.1f}% YoY" if rev_yoy is not None else None)
        ni_val = latest.get("Net Income")
        m2.metric("Net Income", f"${ni_val/1e9:.2f}B" if ni_val and abs(ni_val) >= 1e9 else (f"${ni_val/1e6:.0f}M" if ni_val is not None else "—"), f"{ni_yoy:+.1f}% YoY" if ni_yoy is not None else None)
        om_val = latest.get("Operating Margin %")
        m3.metric("Operating Margin %", f"{om_val:.1f}%" if om_val is not None else "—", f"{om_yoy:+.1f}pp YoY" if om_yoy is not None else None)
        fcf_val = latest.get("FCF")
        m4.metric("FCF", f"${fcf_val/1e9:.2f}B" if fcf_val and abs(fcf_val) >= 1e9 else (f"${fcf_val/1e6:.0f}M" if fcf_val is not None else "—"), f"{fcf_yoy:+.1f}% YoY" if fcf_yoy is not None else None)
        st.caption("FCF = Operating Cash Flow − Capital Expenditure." + (" For Financials, FCF/EBITDA are less relevant; see ROE/ROA in Tab 1 sector-specific metrics." if is_financial else ""))
        if len(df_trend) >= 2 and px is not None:
            st.markdown("#### 5-year trend: Revenue & FCF")
            df_plot = df_trend.copy()
            df_plot["Revenue_M"] = (df_plot["Revenue"] / 1e6).round(1)
            df_plot["FCF_M"] = (df_plot["FCF"] / 1e6).round(1)
            fig = px.line(df_plot, x="Year", y=["Revenue_M", "FCF_M"], title="Revenue & Free Cash Flow ($M)")
            fig.update_layout(yaxis_title="$M", legend_title="", hovermode="x unified")
            fig.update_traces(line=dict(width=2))
            st.plotly_chart(fig, use_container_width=True)
    elif ticker:
        st.caption("5-year trend not available for this ticker. DCF section below uses latest FCF from yfinance.")
    st.markdown("---")
    st.markdown("#### DCF valuation (Excel-style): inputs & 3-scenario output")
    dcf_inputs = get_dcf_inputs(quant_ticker_t2) if quant_ticker_t2 else {"fcf": None, "total_debt": 0.0, "cash": 0.0, "shares": None}
    fcf_fetched = dcf_inputs.get("fcf")
    total_debt = float(dcf_inputs.get("total_debt") or 0.0)
    cash = float(dcf_inputs.get("cash") or 0.0)
    shares_fetched = dcf_inputs.get("shares")
    # Base FCF
    if fcf_fetched is None or fcf_fetched <= 0:
        fcf = st.number_input("Base FCF (manual — only if yfinance missing)", value=0.0, min_value=-1e12, step=1e8, format="%.0f", key="dcf_fcf_manual")
    else:
        fcf = float(fcf_fetched)
        st.caption(f"Base FCF (OCF − CapEx): **${fcf/1e9:.2f}B**" if abs(fcf) >= 1e9 else f"Base FCF (OCF − CapEx): **${fcf/1e6:.0f}M**")
    # Shares: auto-fetched (fast_info → info → balance); manual only as last resort
    if shares_fetched is not None and shares_fetched > 0:
        shares = float(shares_fetched)
        st.caption(f"Shares Outstanding: **{_format_shares_display(shares)}** (real-time, auto-fetched)")
    else:
        shares = st.number_input("Shares Outstanding (manual — only if all API sources failed)", value=1e9, min_value=1.0, step=1e7, format="%.0f", key="dcf_shares_manual")
    # Total Debt & Cash: manual only when both API sources completely failed
    if total_debt == 0 and cash == 0:
        c1, c2 = st.columns(2)
        with c1:
            total_debt = st.number_input("Total Debt (manual — only if all sources failed)", value=0.0, min_value=0.0, step=1e8, format="%.0f", key="dcf_debt_manual")
        with c2:
            cash = st.number_input("Cash & Equivalents (manual — only if all sources failed)", value=0.0, min_value=0.0, step=1e8, format="%.0f", key="dcf_cash_manual")
    else:
        st.caption(f"Total Debt: **${total_debt/1e9:.2f}B**" if total_debt >= 1e9 else f"Total Debt: **${total_debt/1e6:.0f}M**" if total_debt >= 1e6 else f"Total Debt: **${total_debt:,.0f}**")
        st.caption(f"Cash & Equivalents: **${cash/1e9:.2f}B**" if cash >= 1e9 else f"Cash & Equivalents: **${cash/1e6:.0f}M**" if cash >= 1e6 else f"Cash & Equivalents: **${cash:,.0f}**")
    dcf_defaults = get_dcf_smart_defaults(quant_ticker_t2) if quant_ticker_t2 else {"wacc_pct": 10.0, "term_growth_pct": 2.5, "fcf_growth_pct": 8.0}
    st.markdown("**Assumptions (sliders)**")
    st.caption("💡 Slider defaults are auto-generated based on the company's Beta (CAPM) and revenue growth estimates.")
    col1, col2, col3 = st.columns(3)
    with col1:
        wacc = st.slider("WACC (Discount Rate) %", 4.0, 20.0, float(dcf_defaults["wacc_pct"]), 0.5, key="dcf_wacc") / 100.0
    with col2:
        term_growth = st.slider("Terminal Growth Rate %", -2.0, 6.0, float(dcf_defaults["term_growth_pct"]), 0.25, key="dcf_term") / 100.0
    with col3:
        base_growth = st.slider("Projected FCF Growth (Stage 1, Y1–5) %", -10.0, 30.0, float(dcf_defaults["fcf_growth_pct"]), 0.5, key="dcf_fcf_growth") / 100.0
    bull_growth = base_growth + 0.02
    bear_growth = base_growth - 0.02
    with st.expander("Reference: Analyst & Macro Assumptions", expanded=False):
        left_col, right_col = st.columns(2)
        with left_col:
            st.markdown("**Analyst consensus (yfinance)**")
            analyst = get_analyst_consensus(quant_ticker_t2) if quant_ticker_t2 else {}
            st.markdown(f"- **Target mean price:** {analyst.get('targetMeanPrice', 'N/A')}")
            st.markdown(f"- **Recommendation:** {analyst.get('recommendationKey', 'N/A')}")
            st.markdown(f"- **Revenue growth est.:** {analyst.get('revenueGrowth', 'N/A')}")
            st.markdown(f"- **Earnings growth est.:** {analyst.get('earningsGrowth', 'N/A')}")
        with right_col:
            st.markdown("**Aswath Damodaran — macro baseline**")
            sector_name = get_sector_industry(ticker).get("sector", "N/A") if ticker else "N/A"
            damodaran_wacc = _damodaran_wacc_for_sector(sector_name) if ticker else 8.0
            st.markdown(f"- **Sector WACC (ref.):** {damodaran_wacc:.1f}% (closest: {sector_name})")
            st.markdown(f"- **US equity risk premium (ERP):** {DAMODARAN_ERP_PCT}%")
            st.markdown(f"- **10Y risk-free rate:** {DAMODARAN_RF_PCT}%")
            st.markdown("[Data & methodology (Damodaran)](https://pages.stern.nyu.edu/~adamodar/New_Home_Page/datafile/wacc.htm) so users can verify.")
    res_base = excel_style_dcf(fcf, wacc, term_growth, base_growth, total_debt, cash, shares)
    res_bull = excel_style_dcf(fcf, wacc, term_growth, bull_growth, total_debt, cash, shares)
    res_bear = excel_style_dcf(fcf, wacc, term_growth, bear_growth, total_debt, cash, shares)
    price_base = res_base.get("value_per_share") or 0.0
    price_bull = res_bull.get("value_per_share") or 0.0
    price_bear = res_bear.get("value_per_share") or 0.0
    current_price = None
    if quant_ticker_t2 and yf:
        try:
            info = yf.Ticker(quant_ticker_t2.upper()).info or {}
            current_price = info.get("currentPrice") or info.get("regularMarketPrice") or info.get("previousClose")
        except Exception:
            pass
    st.markdown("**Intrinsic value vs current price**")
    if current_price is not None and current_price > 0:
        st.metric("Current price", f"${current_price:.2f}", None)
    st.metric("Base case intrinsic value per share", f"${price_base:.2f}" if price_base else "N/A", f"vs current: {(price_base - current_price):.2f}" if (current_price and price_base) else None)
    c1, c2, c3 = st.columns(3)
    c1.metric("Bull (+2% FCF growth)", f"${price_bull:.2f}" if price_bull else "N/A", f"vs Base: +{(price_bull - price_base):.2f}" if (price_bull and price_base) else None)
    c2.metric("Base", f"${price_base:.2f}" if price_base else "N/A", "—")
    c3.metric("Bear (−2% FCF growth)", f"${price_bear:.2f}" if price_bear else "N/A", f"vs Base: {(price_bear - price_base):.2f}" if (price_bear and price_base) else None)
    df_dcf = pd.DataFrame({
        "Scenario": ["Bull", "Base", "Bear"],
        "FCF Growth %": [f"{bull_growth*100:.1f}", f"{base_growth*100:.1f}", f"{bear_growth*100:.1f}"],
        "Intrinsic Value ($)": [round(price_bull, 2) if price_bull else "N/A", round(price_base, 2) if price_base else "N/A", round(price_bear, 2) if price_bear else "N/A"],
    })
    st.dataframe(df_dcf, use_container_width=True, hide_index=True)

# ----- Tab 3: Top-Down Sector Analysis (Industry Comps + AI Outlook) -----
with tab3:
    st.subheader("Top-Down Sector Analysis")
    st.markdown("Select an **industry** to load peer multiples (Forward P/E, EV/EBITDA, P/B). Green = lowest (undervalued), Red = highest. Optionally generate an **AI Industry Outlook**.")
    sector_options = list(SECTORS.keys())
    selected_industry = st.selectbox("Select industry", sector_options, key="sector_select")
    tickers_list = list(SECTORS.get(selected_industry, []))
    if not tickers_list:
        st.warning("No tickers defined for this industry.")
    else:
        with st.spinner("Fetching market data..."):
            df_comps = get_comps_data(tuple(tickers_list))
        if df_comps.empty:
            st.warning("Could not fetch comps from yfinance. One or more tickers may have failed; try again later.")
        else:
            df_display = df_comps.copy()
            for col in ["Forward P/E", "EV/EBITDA", "P/B"]:
                if col not in df_display.columns:
                    continue
                df_display[col] = df_display[col].apply(
                    lambda x: "N/A" if (x is None or (isinstance(x, float) and pd.isna(x))) else x
                )
            try:
                styled = df_comps.style
                for col in ["Forward P/E", "EV/EBITDA", "P/B"]:
                    if col not in df_comps.columns:
                        continue
                    s = pd.to_numeric(df_comps[col], errors="coerce")
                    valid = s.dropna()
                    if len(valid) < 2:
                        continue
                    lo, hi = valid.min(), valid.max()
                    if lo == hi:
                        continue
                    def color_fn(v, lo_val=lo, hi_val=hi):
                        if pd.isna(v):
                            return ""
                        try:
                            x = float(v)
                        except (TypeError, ValueError):
                            return ""
                        if x <= lo_val:
                            return "background-color: rgba(0, 200, 83, 0.35); color: #0d5c2e"
                        if x >= hi_val:
                            return "background-color: rgba(255, 82, 82, 0.35); color: #b71c1c"
                        return ""
                    styled = styled.map(color_fn, subset=[col])
                styled = styled.format(subset=["Forward P/E", "EV/EBITDA", "P/B"], formatter=lambda x: "N/A" if (pd.isna(x) or x is None) else f"{x:.2f}")
                st.dataframe(styled, use_container_width=True, hide_index=True)
            except Exception:
                st.dataframe(df_display, use_container_width=True, hide_index=True)
        st.caption("Lowest multiple in each column = green (relatively undervalued); highest = red.")

    st.markdown("---")
    st.markdown("#### AI Industry Outlook")
    if st.button("Generate Industry Outlook", key="industry_outlook_btn"):
        if not tickers_list:
            st.error("Select an industry above first.")
        elif not st.session_state.get("google_api_key"):
            st.error("Enter your Google API Key in the sidebar.")
        else:
            try:
                with st.spinner("Generating industry outlook with Gemini..."):
                    report = get_industry_outlook(
                        st.session_state["google_api_key"],
                        selected_industry,
                        tickers_list,
                    )
                st.success("Done.")
                st.markdown(report)
            except RuntimeError as e:
                st.error(str(e))
            except Exception as e:
                st.error("Failed to generate outlook. See details below.")
                with st.expander("Error details"):
                    st.code(repr(e), language="text")