"""Generator pentru data/backtest.xlsx.

5 strategii de management comparate side-by-side pe semnale blackbox:
  - TP0 only       : 100% close la TP0
  - TP1 only       : 100% OCO la SL/TP1
  - TP2 only       : 100% OCO la SL/TP2
  - Hybrid + BE    : 50% TP0 + mut SL la BE + 50% TP1 (recomandat de trader)
  - Hybrid no BE   : 50% TP0 + 50% TP1, fără BE (control pentru a izola valoarea BE-ului)

Rulare:
    pip install openpyxl
    python scripts/generate_template.py
"""

from __future__ import annotations

from datetime import date, time
from pathlib import Path

from openpyxl import Workbook
from openpyxl.chart import LineChart, Reference
from openpyxl.formatting.rule import CellIsRule
from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
from openpyxl.utils import get_column_letter
from openpyxl.worksheet.datavalidation import DataValidation


OUTPUT = Path(__file__).resolve().parent.parent / "data" / "backtest.xlsx"
MAX_ROWS = 500  # rânduri pre-completate cu formule în sheet-ul Trades

# ---------------------------------------------------------------------------
# Styles
# ---------------------------------------------------------------------------

HEADER_FILL = PatternFill("solid", fgColor="1F3864")
HEADER_FONT = Font(name="Calibri", size=11, bold=True, color="FFFFFF")
INPUT_FILL = PatternFill("solid", fgColor="FFF8E1")
DERIVED_FILL = PatternFill("solid", fgColor="E8F1FA")
HIDDEN_FILL = PatternFill("solid", fgColor="F0F0F0")
TITLE_FONT = Font(name="Calibri", size=16, bold=True, color="1F3864")
SUBTITLE_FONT = Font(name="Calibri", size=12, bold=True, color="1F3864")
THIN = Side(border_style="thin", color="BFBFBF")
BORDER = Border(left=THIN, right=THIN, top=THIN, bottom=THIN)
CENTER = Alignment(horizontal="center", vertical="center")
LEFT = Alignment(horizontal="left", vertical="center")
RIGHT = Alignment(horizontal="right", vertical="center")


# ---------------------------------------------------------------------------
# Lists
# ---------------------------------------------------------------------------

STRATEGIES = ["M2D", "EMA cross", "Order block", "Liquidity sweep", "Custom"]
SESSIONS = ["A1", "A2", "A3", "B", "C", "D", "Other"]
INDICATORS = ["DIA", "US30", "SPY", "QQQ", "ES", "NQ"]
TIMEFRAMES = ["1min", "3min", "15min"]
DIRECTIONS = ["Buy", "Sell"]
OUTCOMES = ["SL", "TP0 only", "TP1", "TP2"]

# Cele 5 strategii de management (sufix folosit în numele coloanelor) + label friendly
STRAT_KEYS = ["tp0only", "tp1only", "tp2only", "hybrid_be", "hybrid_nobe"]
STRAT_LABELS = {
    "tp0only": "TP0 only",
    "tp1only": "TP1 only",
    "tp2only": "TP2 only",
    "hybrid_be": "Hybrid + BE",
    "hybrid_nobe": "Hybrid no BE",
}

# ---------------------------------------------------------------------------
# Trades sheet — schema
# ---------------------------------------------------------------------------

INPUT_HEADERS = [
    "#", "Data", "Ora RO", "Zi", "Sesiune",
    "Strategie", "Indicator", "TF",
    "Direcție", "SL %", "TP0 %", "TP1 %", "TP2 %",
    "Outcome", "Notes",
]
DERIVED_HEADERS = (
    [f"R_{s}" for s in STRAT_KEYS]
    + [f"$_{s}" for s in STRAT_KEYS]
    + [f"Bal_{s}" for s in STRAT_KEYS]
)
HELPER_HEADERS = (
    [f"Win_{s}" for s in STRAT_KEYS]
    + [f"Peak_{s}" for s in STRAT_KEYS]
    + [f"DD_{s}" for s in STRAT_KEYS]
)
TRADES_HEADERS = INPUT_HEADERS + DERIVED_HEADERS + HELPER_HEADERS

# Mapă nume → literă coloană Excel
COL = {name: get_column_letter(i + 1) for i, name in enumerate(TRADES_HEADERS)}


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


def _col_to_int(letter: str) -> int:
    n = 0
    for ch in letter:
        n = n * 26 + (ord(ch) - ord("A") + 1)
    return n


# ---------------------------------------------------------------------------
# Config sheet
# ---------------------------------------------------------------------------


def build_config(wb: Workbook) -> None:
    ws = wb.create_sheet("Config", 0)
    ws.sheet_view.showGridLines = False

    ws["A1"] = "📋 Config — editează doar celulele galbene"
    ws["A1"].font = TITLE_FONT
    ws.merge_cells("A1:C1")

    ws["A3"] = "Setting"
    ws["B3"] = "Value"
    ws["C3"] = "Note"
    for c in ("A3", "B3", "C3"):
        ws[c].font = HEADER_FONT
        ws[c].fill = HEADER_FILL
        ws[c].alignment = CENTER

    ws["A4"] = "Account Size Start ($)"
    ws["B4"] = 10000
    ws["C4"] = "Balanța inițială pentru calcule $ și HWM"

    ws["A5"] = "Risk per Trade (%)"
    ws["B5"] = 1.0
    ws["C5"] = "% din account riscat per trade (= -1R)"

    ws["A6"] = "Risk per Trade ($)"
    ws["B6"] = "=B4*B5/100"
    ws["C6"] = "Auto — derivat din B4 și B5"

    for r in (4, 5):
        ws.cell(row=r, column=2).fill = INPUT_FILL
        ws.cell(row=r, column=2).border = BORDER
    ws["B6"].fill = DERIVED_FILL
    ws["B6"].border = BORDER
    ws["B4"].number_format = "$#,##0"
    ws["B5"].number_format = '0.0"%"'
    ws["B6"].number_format = "$#,##0.00"

    # Liste dropdown — coloanele E–J (6 coloane)
    list_columns = [
        ("Strategii", STRATEGIES),
        ("Sesiuni (auto)", SESSIONS),
        ("Indicatori", INDICATORS),
        ("TF", TIMEFRAMES),
        ("Direcție", DIRECTIONS),
        ("Outcome", OUTCOMES),
    ]
    for col_idx, (label, values) in enumerate(list_columns, start=5):
        cell = ws.cell(row=3, column=col_idx, value=label)
        cell.font = HEADER_FONT
        cell.fill = HEADER_FILL
        cell.alignment = CENTER
        for row_idx, v in enumerate(values, start=4):
            c = ws.cell(row=row_idx, column=col_idx, value=v)
            c.alignment = CENTER

    widths = {
        "A": 24, "B": 14, "C": 38, "D": 2,
        "E": 14, "F": 14, "G": 13, "H": 10, "I": 10, "J": 12,
    }
    for col, w in widths.items():
        ws.column_dimensions[col].width = w


# ---------------------------------------------------------------------------
# Formula builders pentru Trades sheet
# ---------------------------------------------------------------------------


def _f_day(r: int) -> str:
    d = f'{COL["Data"]}{r}'
    return (
        f'=IF({d}="","",'
        f'CHOOSE(WEEKDAY({d},2),"Lu","Ma","Mi","Jo","Vi","Sa","Du"))'
    )


def _f_session(r: int) -> str:
    """Derivă Sesiunea M2D din Data + Ora RO."""
    d = f'{COL["Data"]}{r}'
    t = f'{COL["Ora RO"]}{r}'
    wd = f"WEEKDAY({d},2)"
    mid_week = f"AND({wd}>=2,{wd}<=4)"
    return (
        f'=IF(OR({d}="",{t}=""),"",'
        f"IF(OR({wd}=1,{wd}=5),\"D\","
        f'IF(AND({t}>=TIME(15,30,0),{t}<TIME(16,30,0)),"C",'
        f'IF(AND({mid_week},{t}>=TIME(16,35,0),{t}<TIME(17,0,0)),"A1",'
        f'IF(AND({mid_week},{t}>=TIME(17,0,0),{t}<TIME(18,0,0)),"A2",'
        f'IF(AND({mid_week},{t}>=TIME(18,0,0),{t}<TIME(19,0,0)),"A3",'
        f'IF(AND({mid_week},{t}>=TIME(22,0,0),{t}<TIME(22,45,0)),"B",'
        f'"Other")))))))'
    )


def _f_r_tp0only(r: int) -> str:
    o = f'{COL["Outcome"]}{r}'
    sl = f'{COL["SL %"]}{r}'
    tp0 = f'{COL["TP0 %"]}{r}'
    return f'=IF({o}="","",IF({o}="SL",-1,{tp0}/{sl}))'


def _f_r_tp1only(r: int) -> str:
    o = f'{COL["Outcome"]}{r}'
    sl = f'{COL["SL %"]}{r}'
    tp1 = f'{COL["TP1 %"]}{r}'
    return (
        f'=IF({o}="","",'
        f'IF(OR({o}="SL",{o}="TP0 only"),-1,{tp1}/{sl}))'
    )


def _f_r_tp2only(r: int) -> str:
    o = f'{COL["Outcome"]}{r}'
    sl = f'{COL["SL %"]}{r}'
    tp2 = f'{COL["TP2 %"]}{r}'
    return f'=IF({o}="","",IF({o}="TP2",{tp2}/{sl},-1))'


def _f_r_hybrid_be(r: int) -> str:
    o = f'{COL["Outcome"]}{r}'
    sl = f'{COL["SL %"]}{r}'
    tp0 = f'{COL["TP0 %"]}{r}'
    tp1 = f'{COL["TP1 %"]}{r}'
    return (
        f'=IF({o}="","",'
        f'IF({o}="SL",-1,'
        f'IF({o}="TP0 only",0.5*{tp0}/{sl},'
        f'0.5*({tp0}+{tp1})/{sl})))'
    )


def _f_r_hybrid_nobe(r: int) -> str:
    o = f'{COL["Outcome"]}{r}'
    sl = f'{COL["SL %"]}{r}'
    tp0 = f'{COL["TP0 %"]}{r}'
    tp1 = f'{COL["TP1 %"]}{r}'
    return (
        f'=IF({o}="","",'
        f'IF({o}="SL",-1,'
        f'IF({o}="TP0 only",0.5*{tp0}/{sl}-0.5,'
        f'0.5*({tp0}+{tp1})/{sl})))'
    )


R_FN: dict[str, callable] = {
    "tp0only": _f_r_tp0only,
    "tp1only": _f_r_tp1only,
    "tp2only": _f_r_tp2only,
    "hybrid_be": _f_r_hybrid_be,
    "hybrid_nobe": _f_r_hybrid_nobe,
}


def _f_dollar(r: int, r_col: str) -> str:
    rc = f"{COL[r_col]}{r}"
    return f'=IF({rc}="","",{rc}*Config!$B$6)'


def _f_balance(r: int, dollar_col: str) -> str:
    dc = COL[dollar_col]
    return f'=IF({dc}{r}="","",Config!$B$4 + SUM(${dc}$2:{dc}{r}))'


def _f_win(r: int, r_col: str) -> str:
    rc = f"{COL[r_col]}{r}"
    return f'=IF({rc}="","",IF({rc}>0,1,0))'


def _f_peak(r: int, balance_col: str, peak_col: str) -> str:
    bc = COL[balance_col]
    pc = COL[peak_col]
    if r == 2:
        return f'=IF({bc}{r}="","",{bc}{r})'
    return (
        f'=IF({bc}{r}="","",'
        f'IF({pc}{r-1}="",{bc}{r},MAX({pc}{r-1},{bc}{r})))'
    )


def _f_drawdown(r: int, peak_col: str, balance_col: str) -> str:
    pc = f"{COL[peak_col]}{r}"
    bc = f"{COL[balance_col]}{r}"
    return f'=IF({bc}="","",{pc}-{bc})'


# ---------------------------------------------------------------------------
# Trades sheet
# ---------------------------------------------------------------------------


def build_trades(wb: Workbook) -> None:
    ws = wb.create_sheet("Trades", 1)
    ws.sheet_view.showGridLines = False
    ws.freeze_panes = "B2"

    # Headers
    for col_idx, header in enumerate(TRADES_HEADERS, start=1):
        cell = ws.cell(row=1, column=col_idx, value=header)
        cell.font = HEADER_FONT
        cell.fill = HEADER_FILL
        cell.alignment = CENTER
        cell.border = BORDER

    # Formule pe toate rândurile pre-pregătite
    for r in range(2, MAX_ROWS + 2):
        ws.cell(row=r, column=1, value="=ROW()-1")
        ws[f'{COL["Zi"]}{r}'] = _f_day(r)
        ws[f'{COL["Sesiune"]}{r}'] = _f_session(r)

        for strat in STRAT_KEYS:
            ws[f'{COL[f"R_{strat}"]}{r}'] = R_FN[strat](r)
            ws[f'{COL[f"$_{strat}"]}{r}'] = _f_dollar(r, f"R_{strat}")
            ws[f'{COL[f"Bal_{strat}"]}{r}'] = _f_balance(r, f"$_{strat}")
            ws[f'{COL[f"Win_{strat}"]}{r}'] = _f_win(r, f"R_{strat}")
            ws[f'{COL[f"Peak_{strat}"]}{r}'] = _f_peak(
                r, f"Bal_{strat}", f"Peak_{strat}"
            )
            ws[f'{COL[f"DD_{strat}"]}{r}'] = _f_drawdown(
                r, f"Peak_{strat}", f"Bal_{strat}"
            )

    # Sample row 2
    ws["B2"] = date(2026, 5, 13)
    ws["C2"] = time(17, 33)
    ws[f'{COL["Strategie"]}2'] = "M2D"
    ws[f'{COL["Indicator"]}2'] = "DIA"
    ws[f'{COL["TF"]}2'] = "1min"
    ws[f'{COL["Direcție"]}2'] = "Sell"
    ws[f'{COL["SL %"]}2'] = 0.30
    ws[f'{COL["TP0 %"]}2'] = 0.10
    ws[f'{COL["TP1 %"]}2'] = 0.15
    ws[f'{COL["TP2 %"]}2'] = 0.30
    ws[f'{COL["Outcome"]}2'] = "TP1"
    ws[f'{COL["Notes"]}2'] = "Exemplu — șterge când începi"

    # Number formats
    for col_name in ("SL %", "TP0 %", "TP1 %", "TP2 %"):
        for r in range(2, MAX_ROWS + 2):
            ws[f"{COL[col_name]}{r}"].number_format = '0.000"%"'

    for strat in STRAT_KEYS:
        for r in range(2, MAX_ROWS + 2):
            ws[f"{COL[f'R_{strat}']}{r}"].number_format = "+0.000;-0.000;0.000"
            for prefix in ("$_", "Bal_", "Peak_", "DD_"):
                ws[f"{COL[f'{prefix}{strat}']}{r}"].number_format = '"$"#,##0.00'

    for r in range(2, MAX_ROWS + 2):
        ws[f"B{r}"].number_format = "yyyy-mm-dd"

    # Coloring
    input_letters = {
        COL[n]
        for n in (
            "Data", "Ora RO", "Strategie", "Indicator", "TF",
            "Direcție", "SL %", "TP0 %", "TP1 %", "TP2 %",
            "Outcome", "Notes",
        )
    }
    derived_letters = {COL["Zi"], COL["Sesiune"]}
    for strat in STRAT_KEYS:
        derived_letters.add(COL[f"R_{strat}"])
        derived_letters.add(COL[f"$_{strat}"])
        derived_letters.add(COL[f"Bal_{strat}"])
    helper_letters = set()
    for strat in STRAT_KEYS:
        for prefix in ("Win_", "Peak_", "DD_"):
            helper_letters.add(COL[f"{prefix}{strat}"])

    for r in range(2, MAX_ROWS + 2):
        for cl in input_letters:
            ws[f"{cl}{r}"].fill = INPUT_FILL
        for cl in derived_letters:
            ws[f"{cl}{r}"].fill = DERIVED_FILL
        for cl in helper_letters:
            ws[f"{cl}{r}"].fill = HIDDEN_FILL

    # Column widths
    widths = {
        "A": 5, "B": 12, "C": 9, "D": 5, "E": 9,
        "F": 12, "G": 11, "H": 8, "I": 9,
        "J": 9, "K": 9, "L": 9, "M": 9,
        "N": 11, "O": 28,
    }
    for col, w in widths.items():
        ws.column_dimensions[col].width = w
    # Derived + helper: width 11
    for strat in STRAT_KEYS:
        for prefix in ("R_", "$_", "Bal_", "Win_", "Peak_", "DD_"):
            ws.column_dimensions[COL[f"{prefix}{strat}"]].width = 11

    # Data validation dropdowns
    def _add_dv(col_name: str, source: str) -> None:
        cl = COL[col_name]
        dv = DataValidation(
            type="list", formula1=source,
            allow_blank=True, showErrorMessage=True,
        )
        dv.error = "Valoare invalidă — folosește dropdown-ul."
        dv.errorTitle = "Input invalid"
        dv.add(f"{cl}2:{cl}{MAX_ROWS + 1}")
        ws.add_data_validation(dv)

    # Config columns: E=Strategii, F=Sesiuni, G=Indicatori, H=TF, I=Direcție, J=Outcome
    _add_dv("Strategie", "=Config!$E$4:$E$8")
    _add_dv("Indicator", "=Config!$G$4:$G$9")
    _add_dv("TF", "=Config!$H$4:$H$6")
    _add_dv("Direcție", "=Config!$I$4:$I$5")
    _add_dv("Outcome", "=Config!$J$4:$J$7")

    # Conditional formatting pe coloanele R (5 strategii)
    green_fill = PatternFill("solid", fgColor="C6EFCE")
    red_fill = PatternFill("solid", fgColor="FFC7CE")
    grey_fill = PatternFill("solid", fgColor="D9D9D9")
    for strat in STRAT_KEYS:
        cl = COL[f"R_{strat}"]
        rng = f"{cl}2:{cl}{MAX_ROWS + 1}"
        ws.conditional_formatting.add(
            rng, CellIsRule(operator="greaterThan", formula=["0"], fill=green_fill)
        )
        ws.conditional_formatting.add(
            rng, CellIsRule(operator="lessThan", formula=["0"], fill=red_fill)
        )
        ws.conditional_formatting.add(
            rng, CellIsRule(operator="equal", formula=["0"], fill=grey_fill)
        )


# ---------------------------------------------------------------------------
# Dashboard sheet
# ---------------------------------------------------------------------------


def _range(col_name: str) -> str:
    cl = COL[col_name]
    return f"Trades!${cl}$2:${cl}${MAX_ROWS + 1}"


METRIC_HINTS: dict[str, str] = {
    "Trades Placed": "Numărul total de trade-uri logate",
    "Wins": "Trade-uri cu R > 0",
    "Win Ratio": "% wins. Singur NU spune mult — vezi împreună cu R:R și Expectancy",
    "Average Win ($)": "Câștigul mediu pe trade winning",
    "Average Loss ($)": "Pierderea medie pe trade losing",
    "Best Trade ($)": "Cel mai mare câștig individual",
    "Worst Trade ($)": "Cea mai mare pierdere individuală",
    "Profit Factor": ">1.0 profitabil • >1.5 solid • >2.0 foarte bun • <1.0 pierzător",
    "Risk:Reward": "Avg Win ÷ |Avg Loss|. >1 = câștig mediu > pierdere medie",
    "Expectancy (R)": "★ STEAUA NORDULUI ★ >+0.20R = GO LIVE • negativ = ABANDON",
    "Expectancy ($)": "Expectancy R convertit în $ (folosește Risk per Trade)",
    "Cumulative P&L ($)": "P&L total în $ pe toate trade-urile",
    "HWM Balance ($)": "Highest watermark — balanța de vârf atinsă",
    "Max Drawdown ($)": "Cea mai mare cădere ($) din vârf la fund",
}


def build_dashboard(wb: Workbook) -> None:
    ws = wb.create_sheet("Dashboard", 2)
    ws.sheet_view.showGridLines = False

    ws["A1"] = "📊 Backtest Dashboard"
    ws["A1"].font = TITLE_FONT
    ws.merge_cells("A1:G1")

    ws["A2"] = (
        "Comparație 5 strategii management — pe aceleași semnale blackbox"
    )
    ws["A2"].font = Font(name="Calibri", size=10, italic=True, color="595959")
    ws.merge_cells("A2:G2")

    # Row 4: headers (5 columns B-F pentru strategii + G pentru "Cum citesc")
    ws["A4"] = "Metric"
    strat_cols = {}  # strat_key → column letter (B/C/D/E/F)
    for i, strat in enumerate(STRAT_KEYS):
        letter = get_column_letter(2 + i)
        strat_cols[strat] = letter
        ws[f"{letter}4"] = STRAT_LABELS[strat]
    ws["G4"] = "Cum citesc"
    for letter in ["A"] + list(strat_cols.values()) + ["G"]:
        c = ws[f"{letter}4"]
        c.font = HEADER_FONT
        c.fill = HEADER_FILL
        c.alignment = CENTER
        c.border = BORDER

    # Ranges per strategie
    R = {s: _range(f"R_{s}") for s in STRAT_KEYS}
    D = {s: _range(f"$_{s}") for s in STRAT_KEYS}
    W = {s: _range(f"Win_{s}") for s in STRAT_KEYS}
    BAL = {s: _range(f"Bal_{s}") for s in STRAT_KEYS}
    DD = {s: _range(f"DD_{s}") for s in STRAT_KEYS}
    OUTCOME_RANGE = _range("Outcome")

    # Metric rows — fiecare metric e un dict cu per-strategy formula + format
    metrics: list[tuple[str, callable, str]] = [
        # (label, fn(strat_key) -> formula, number_format)
        ("Trades Placed", lambda s: f'=COUNTA({OUTCOME_RANGE})', "0"),
        ("Wins", lambda s: f'=COUNTIF({W[s]},1)', "0"),
        # Win Ratio: depends on rows above — handled after metrics list (placeholder)
        ("Win Ratio", lambda s: None, "0.0%"),
        ("Average Win ($)", lambda s: f'=IFERROR(AVERAGEIF({D[s]},">0"),0)', '"$"#,##0.00'),
        ("Average Loss ($)", lambda s: f'=IFERROR(AVERAGEIF({D[s]},"<0"),0)', '"$"#,##0.00'),
        ("Best Trade ($)", lambda s: f'=IFERROR(MAX({D[s]}),0)', '"$"#,##0.00'),
        ("Worst Trade ($)", lambda s: f'=IFERROR(MIN({D[s]}),0)', '"$"#,##0.00'),
        ("Profit Factor", lambda s: f'=IFERROR(SUMIF({D[s]},">0")/ABS(SUMIF({D[s]},"<0")),0)', "0.00"),
        # Risk:Reward — placeholder; bazat pe rândurile Avg Win/Loss
        ("Risk:Reward", lambda s: None, "0.00"),
        ("Expectancy (R)", lambda s: f'=IFERROR(AVERAGE({R[s]}),0)', "+0.000;-0.000;0.000"),
        ("Expectancy ($)", lambda s: f'=IFERROR(AVERAGE({D[s]}),0)', '"$"#,##0.00'),
        ("Cumulative P&L ($)", lambda s: f'=SUM({D[s]})', '"$"#,##0.00'),
        # HWM — placeholder cu ref la Trades Placed (row 5)
        ("HWM Balance ($)", lambda s: None, '"$"#,##0.00'),
        ("Max Drawdown ($)", lambda s: f'=IFERROR(MAX({DD[s]}),0)', '"$"#,##0.00'),
    ]

    # Determine row indexes pentru formule speciale (depind de poziție)
    label_to_row = {label: 5 + idx for idx, (label, _, _) in enumerate(metrics)}
    trades_row = label_to_row["Trades Placed"]
    wins_row = label_to_row["Wins"]
    avg_win_row = label_to_row["Average Win ($)"]
    avg_loss_row = label_to_row["Average Loss ($)"]

    for idx, (label, fn, fmt) in enumerate(metrics):
        r = 5 + idx
        ws[f"A{r}"] = label
        ws[f"A{r}"].font = Font(name="Calibri", size=11, bold=True)
        ws[f"A{r}"].border = BORDER
        ws[f"A{r}"].alignment = LEFT
        for strat in STRAT_KEYS:
            letter = strat_cols[strat]
            if label == "Win Ratio":
                formula = f"=IFERROR({letter}{wins_row}/{letter}{trades_row},0)"
            elif label == "Risk:Reward":
                formula = f"=IFERROR({letter}{avg_win_row}/ABS({letter}{avg_loss_row}),0)"
            elif label == "HWM Balance ($)":
                formula = (
                    f"=IF({letter}{trades_row}=0,Config!$B$4,MAX({BAL[strat]}))"
                )
            else:
                formula = fn(strat)
            cell = ws[f"{letter}{r}"]
            cell.value = formula
            cell.number_format = fmt
            cell.fill = DERIVED_FILL
            cell.border = BORDER
            cell.alignment = RIGHT
        # Coloana G — interpretare scurtă
        hint_cell = ws[f"G{r}"]
        hint_cell.value = METRIC_HINTS.get(label, "")
        hint_cell.font = Font(name="Calibri", size=10, italic=True, color="595959")
        hint_cell.alignment = Alignment(horizontal="left", vertical="center", wrap_text=True)
        hint_cell.border = BORDER

    # ---- Glosar section: exemple concrete pentru metricile-cheie ----
    glosar_start = 5 + len(metrics) + 2  # 2 rânduri spațiu după metrici
    ws[f"A{glosar_start}"] = "📖 Glosar metrici — exemple concrete"
    ws[f"A{glosar_start}"].font = SUBTITLE_FONT
    ws.merge_cells(f"A{glosar_start}:G{glosar_start}")

    glosar_entries = [
        (
            "Profit Factor",
            "Suma câștigurilor ÷ |suma pierderilor|. Total cumulativ, nu mediu.",
            "10 trade-uri: 4 wins de $50 (=$200) + 6 losses de −$30 (=−$180). PF = 200÷180 = 1.11 (marginal profitabil). La PF=2.0 câștigi de 2× cât pierzi în total.",
        ),
        (
            "Risk:Reward",
            "Avg Win ÷ |Avg Loss|. Privește per-trade, nu total.",
            "Avg win $50, avg loss −$30 → R:R = 1.67. La R:R=2.0 ești profitabil chiar cu Win Ratio doar 40%. La R:R=0.5 ai nevoie de WR >67%.",
        ),
        (
            "Expectancy (R)",
            "Câștigul mediu per trade exprimat în multipli de risc (R). CEA MAI ONESTĂ metrică — combină WR și R:R într-un singur număr.",
            "10 trade-uri cu R = [+0.5, +0.5, +0.5, +0.5, −1, −1, −1, −1, −1, −1] → media = −0.30R (pierdere) chiar dacă WR=40%. Pragul GO LIVE din STOPPING_RULE.md: ≥ +0.20R.",
        ),
        (
            "Win Ratio (WR)",
            "% trade-uri cu R > 0. ÎNȘELĂTOR singur — un WR mare cu R:R mic poate fi pierzător.",
            "WR=70% pare excelent, dar dacă R:R=0.3 (câștigi $30, pierzi $100) → Expectancy = 0.7·30 − 0.3·100 = −$9 per trade. Pierzător.",
        ),
        (
            "Max Drawdown",
            "Cea mai mare cădere din vârful balanței la fundul ulterior. Măsoară 'durerea psihologică'.",
            "Balance peak $11,500 → fund $9,800 → DD = $1,700 (17% din peak). DD mare la backtest = greu de tolerat în live.",
        ),
    ]

    row = glosar_start + 1
    for term, definition, example in glosar_entries:
        ws[f"A{row}"] = term
        ws[f"A{row}"].font = Font(name="Calibri", size=11, bold=True, color="1F3864")
        ws[f"A{row}"].alignment = Alignment(horizontal="left", vertical="top", wrap_text=True)
        ws[f"B{row}"] = definition
        ws[f"B{row}"].font = Font(name="Calibri", size=10)
        ws[f"B{row}"].alignment = Alignment(horizontal="left", vertical="top", wrap_text=True)
        ws.merge_cells(f"B{row}:C{row}")
        ws[f"D{row}"] = f"Exemplu: {example}"
        ws[f"D{row}"].font = Font(name="Calibri", size=10, italic=True, color="595959")
        ws[f"D{row}"].alignment = Alignment(horizontal="left", vertical="top", wrap_text=True)
        ws.merge_cells(f"D{row}:G{row}")
        ws.row_dimensions[row].height = 48
        row += 1

    glosar_end = row  # primul rând după glosar

    # Helper pentru a emite un block breakdown (per Sesiune / Strategie / etc.)
    def _emit_breakdown(
        start_row: int, title: str, first_col_label: str,
        items: list[str], item_range: str, overlay_strat: str,
    ) -> int:
        ws[f"A{start_row}"] = title
        ws[f"A{start_row}"].font = SUBTITLE_FONT
        ws.merge_cells(f"A{start_row}:F{start_row}")
        headers = [first_col_label, "N", "Wins", "WR", "Expectancy R", "Cum $"]
        for col_idx, h in enumerate(headers, start=1):
            c = ws.cell(row=start_row + 1, column=col_idx, value=h)
            c.font = HEADER_FONT
            c.fill = HEADER_FILL
            c.alignment = CENTER
            c.border = BORDER
        for i, item in enumerate(items):
            r = start_row + 2 + i
            ws[f"A{r}"] = item
            ws[f"B{r}"] = f'=COUNTIF({item_range},"{item}")'
            ws[f"C{r}"] = f'=COUNTIFS({item_range},"{item}",{W[overlay_strat]},1)'
            ws[f"D{r}"] = f"=IFERROR(C{r}/B{r},0)"
            ws[f"E{r}"] = (
                f'=IFERROR(AVERAGEIFS({R[overlay_strat]},{item_range},"{item}"),0)'
            )
            ws[f"F{r}"] = f'=SUMIFS({D[overlay_strat]},{item_range},"{item}")'
            ws[f"B{r}"].number_format = "0"
            ws[f"C{r}"].number_format = "0"
            ws[f"D{r}"].number_format = "0.0%"
            ws[f"E{r}"].number_format = "+0.000;-0.000;0.000"
            ws[f"F{r}"].number_format = '"$"#,##0.00'
            for c in ("A", "B", "C", "D", "E", "F"):
                ws[f"{c}{r}"].border = BORDER
                ws[f"{c}{r}"].alignment = RIGHT if c != "A" else LEFT
        return start_row + 2 + len(items)

    # Breakdowns — toate folosesc overlay-ul Hybrid+BE (recomandat de trader)
    overlay = "hybrid_be"
    start = glosar_end + 2  # 2 rânduri spațiu după glosar
    after_sess = _emit_breakdown(
        start, "PER SESIUNE (overlay: Hybrid + BE)", "Sesiune",
        SESSIONS, _range("Sesiune"), overlay,
    )
    after_strat = _emit_breakdown(
        after_sess + 2, "PER STRATEGIE (overlay: Hybrid + BE)", "Strategie",
        STRATEGIES, _range("Strategie"), overlay,
    )
    after_ind = _emit_breakdown(
        after_strat + 2, "PER INDICATOR (overlay: Hybrid + BE)", "Indicator",
        INDICATORS, _range("Indicator"), overlay,
    )
    _emit_breakdown(
        after_ind + 2, "PER DIRECȚIE (overlay: Hybrid + BE)", "Direcție",
        DIRECTIONS, _range("Direcție"), overlay,
    )

    # Column widths
    widths = {"A": 22, "B": 14, "C": 14, "D": 14, "E": 16, "F": 16, "G": 50}
    for col, w in widths.items():
        ws.column_dimensions[col].width = w

    # Row height pentru rândurile cu hint (cu wrap)
    for r in range(5, 5 + len(metrics)):
        ws.row_dimensions[r].height = 22

    # Equity curve chart — 5 linii
    chart = LineChart()
    chart.title = "Equity Curve — 5 strategii"
    chart.style = 12
    chart.y_axis.title = "Balance ($)"
    chart.x_axis.title = "Trade #"
    chart.height = 12
    chart.width = 24

    data = Reference(
        wb["Trades"],
        min_col=_col_to_int(COL[f"Bal_{STRAT_KEYS[0]}"]),
        max_col=_col_to_int(COL[f"Bal_{STRAT_KEYS[-1]}"]),
        min_row=1,
        max_row=MAX_ROWS + 1,
    )
    chart.add_data(data, titles_from_data=True)
    cats = Reference(
        wb["Trades"], min_col=1, max_col=1,
        min_row=2, max_row=MAX_ROWS + 1,
    )
    chart.set_categories(cats)
    ws.add_chart(chart, "H4")


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------


def build_workbook() -> Workbook:
    wb = Workbook()
    default = wb.active
    wb.remove(default)
    build_config(wb)
    build_trades(wb)
    build_dashboard(wb)
    wb.active = wb.sheetnames.index("Dashboard")
    return wb


def main() -> int:
    OUTPUT.parent.mkdir(parents=True, exist_ok=True)
    wb = build_workbook()
    wb.save(OUTPUT)
    print(f"Wrote {OUTPUT}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())