#!/usr/bin/python3.11
__AUTHOR__    = "Sean Watkins : swatkins@cohesity.com"
__COPYRIGHT__ = "Copyright 2025, Cohesity Inc"
# This script installs the contents of the manifest.json

import argparse
import curses
import datetime
import hashlib
import json
import logging
import multiprocessing as mp
import os
import re
import subprocess
import sys
import threading
import time
from getpass import getuser
from signal import signal, SIGTSTP, SIGINT
from typing import Any

sys.pycache_prefix = '/tmp'

# ── Constants ──────────────────────────────────────────────────────────────────
COHESITY_BIN_PATH = "/home/cohesity/bin"
MANIFEST          = 'manifest.json'
RELEASE_NOTES     = 'releaseNotes.md'
TIMEOUT           = 180

# ── Logging ────────────────────────────────────────────────────────────────────
logging.basicConfig(
    filename='odin_installer.INFO',
    level=logging.DEBUG,
    filemode='w',
)

# ── Signal handlers ────────────────────────────────────────────────────────────
def sigint_handler(sig, frame):
    sys.exit(0)

def sigtstp_handler(sig, frame):
    sys.exit(0)

# ── Shell helpers ──────────────────────────────────────────────────────────────
def run_cmd(command: list, timeout: int = TIMEOUT) -> tuple:
    """Run a shell command; return (stdout, stderr, returncode)."""
    try:
        r = subprocess.run(
            command,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            timeout=timeout,
        )
        out = r.stdout.decode('utf-8', errors='replace') if r.stdout else ''
        err = r.stderr.decode('utf-8', errors='replace') if r.stderr else ''
        return out, err, r.returncode
    except subprocess.TimeoutExpired as e:
        out = e.stdout.decode('utf-8', errors='replace') if e.stdout else ''
        err = e.stderr.decode('utf-8', errors='replace') if e.stderr else ''
        return out, err, 666
    except Exception as e:
        return '', str(e), 666


def check_sudo() -> bool:
    """Return True if passwordless sudo is available."""
    try:
        r = subprocess.run(
            ['sudo', '-n', 'true'],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            timeout=5,
        )
        return r.returncode == 0
    except (FileNotFoundError, subprocess.TimeoutExpired):
        return False


def get_cluster_ips() -> tuple:
    """Return (ip_list, is_ipv6) discovered via the cohesity hostips binary."""
    cmd = f"{COHESITY_BIN_PATH}/hostips"
    r   = subprocess.run(
        cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=TIMEOUT
    )
    if r.returncode != 0:
        err = r.stderr.decode('utf-8', errors='replace') if r.stderr else ''
        logging.critical(f"hostips failed: {err}")
        sys.exit(f"Error: unable to get cluster IPs – {err.strip()}")
    ips   = r.stdout.decode('utf-8', errors='replace').split()
    is_v6 = any(':' in ip for ip in ips)
    return ips, is_v6


# ── Installer ──────────────────────────────────────────────────────────────────
class Installer:
    """
    Manages SSH/SCP operations against all cluster nodes.

    Each node is handled independently by install_node() so the curses
    UI can show live per-node progress.
    """

    def __init__(self, args: dict):
        with open(MANIFEST, 'r') as f:
            self.manifest = json.load(f)

        if not check_sudo():
            sys.exit("Error: sudo is not available – enable passwordless sudo and retry.")

        self.installdir = os.getcwd()
        self.hostips, self.v6 = get_cluster_ips()

        self.rpms     = [x for x in self.manifest['RPMS'] if x.endswith('.rpm')]
        self.tmpRpm   = [f"/tmp/{x}" for x in self.rpms]
        self.rpmShort = []
        for rpm in self.rpms:
            parts = rpm.replace('.rpm', '').split('-')
            if len(parts) >= 2:
                self.rpmShort.append(f"{parts[0]}-{parts[1]}")

        self.package = self.manifest['Package']
        self.version = self.manifest['Version']
        self.user    = getuser()
        self.port    = str(args['port'])

        flag6 = ['-6'] if self.v6 else []
        self.sshOpts = [
            '/home/cohesity/software/crux/bin/ssh', *flag6,
            '-p', self.port,
            '-o', 'ConnectTimeout=5',
            '-o', 'PreferredAuthentications=publickey,password',
            '-o', 'StrictHostKeyChecking=no',
            '-o', 'UserKnownHostsFile=/dev/null',
            '-o', 'LogLevel=ERROR',
        ]
        self.scpOpts = [
            '/home/cohesity/software/crux/bin/scp', *flag6,
            '-P', self.port,
            '-o', 'StrictHostKeyChecking=no',
            '-o', 'UserKnownHostsFile=/dev/null',
            '-o', 'LogLevel=ERROR',
        ]

    # ── Integrity check ───────────────────────────────────────────────────────
    def check(self) -> tuple:
        """
        Verify SHA-256 of every local RPM against the manifest.
        Returns (ok: bool, errors: list[str]).
        """
        errors = []
        for rpm in self.rpms:
            if not os.path.exists(rpm):
                errors.append(f"RPM not found: {rpm}")
                continue
            sha = hashlib.sha256()
            with open(rpm, 'rb') as f:
                while chunk := f.read(8192):
                    sha.update(chunk)
            expected = self.manifest['RPMS'].get(rpm, '')
            if sha.hexdigest() != expected:
                errors.append(f"SHA-256 mismatch: {rpm}")
        return (len(errors) == 0), errors

    # ── SSH / SCP wrappers ────────────────────────────────────────────────────
    def _ssh(self, addr: str, cmd_str: str) -> tuple:
        return run_cmd([*self.sshOpts, f"{self.user}@{addr}", cmd_str])

    def _scp(self, src: str, addr: str, dst: str) -> tuple:
        return run_cmd([*self.scpOpts, src, f"{addr}:{dst}"])

    # ── Per-node full install sequence ────────────────────────────────────────
    def install_node(self, ip: str, progress: dict) -> None:
        """
        Run copy → install → cleanup for a single node.

        progress[ip] keys:
          phase  : 'pending'|'copy'|'install'|'cleanup'|'done'|'fail'
          detail : short status string shown in the UI bar
          errors : list of error strings
        """
        lock   = progress['_lock']
        addr   = f"[{ip}]" if self.v6 else ip
        errors = []

        def set_phase(phase: str, detail: str = ''):
            with lock:
                progress[ip]['phase']  = phase
                progress[ip]['detail'] = detail

        def fail(detail: str, msg: str):
            logging.critical(msg)
            errors.append(msg)
            with lock:
                progress[ip].update({'phase': 'fail', 'detail': detail, 'errors': errors})

        # ── Phase 1 : remove old packages + copy RPMs ────────────────────
        set_phase('copy', 'rpm -e old packages')
        old_remove = (
            f"for i in $(sudo rpm -q "
            f"{' '.join(self.rpmShort)} support-toolbox-3.0.0 2>/dev/null "
            f"| grep -v 'not installed'); "
            f"do sudo rpm -e $i --nodeps || true; done"
        )
        out, err, code = self._ssh(addr, old_remove)
        if code not in (0, 1):
            logging.warning(f"[{ip}] old-pkg remove warning (code {code}): {err.strip()}")

        set_phase('copy', f"scp {len(self.rpms)} RPMs -> /tmp/")
        for rpm in self.rpms:
            out, err, code = self._scp(
                f"{self.installdir}/{rpm}", addr, f"/tmp/{rpm}"
            )
            if code != 0:
                fail('copy failed', f"[{ip}] scp {rpm} failed (code {code}): {err.strip()}")
                return

        set_phase('copy', 'test -f each RPM')
        verify_cmd = (
            f"for f in {' '.join(self.tmpRpm)}; "
            f"do test -f \"$f\" || exit 1; done; echo ok"
        )
        out, err, code = self._ssh(addr, verify_cmd)
        if code != 0:
            fail('copy verify failed', f"[{ip}] copy verify failed: {err.strip()}")
            return

        # ── Phase 2 : RPM install ─────────────────────────────────────────
        set_phase('install', f"rpm -Uhv --nodeps --force ({len(self.rpms)} pkgs)")
        install_cmd = f"sudo rpm -Uhv --nodeps --force {' '.join(self.tmpRpm)}"
        out, err, code = self._ssh(addr, install_cmd)
        if code != 0:
            fail('install failed', f"[{ip}] rpm install failed (code {code}): {err.strip()}")
            return

        set_phase('install', f"rpm -q {' '.join(self.rpmShort)}")
        out, err, code = self._ssh(addr, f"sudo rpm -q {' '.join(self.rpmShort)}")
        for line in out.splitlines():
            if 'not installed' in line:
                fail('install verify failed',
                     f"[{ip}] rpm verify: {line.strip()}")
                return

        # ── Phase 3 : cleanup ─────────────────────────────────────────────
        set_phase('cleanup', 'rm /tmp/*.rpm')
        for cmd_str in [
            f"sudo rm -f {' '.join(self.tmpRpm)}",
            "sudo rm -rf ./manifest.json ./install ./st-*.rpm",
            (
                "mv ./odin_installer.INFO "
                "/cohesity_logs/support-toolbox/odin_installer.INFO "
                "2>/dev/null; "
                "sudo chown cohesity: "
                "/cohesity_logs/support-toolbox/odin_installer.INFO "
                "2>/dev/null || true"
            ),
        ]:
            out, err, code = self._ssh(addr, cmd_str)
            if code != 0:
                logging.warning(f"[{ip}] cleanup warning: {err.strip()}")

        with lock:
            progress[ip].update({'phase': 'done', 'detail': '', 'errors': []})


# ── Release-notes parser ───────────────────────────────────────────────────────
def parse_release_notes(path: str) -> dict:
    """
    Return a dict:
      build, version, commit, tickets, summary (str)
      packages  : list of (name, version) tuples
      checksums : list of (file, hash) tuples
    """
    result = {
        'build': '', 'version': '', 'commit': '',
        'tickets': '', 'summary': '',
        'packages': [], 'checksums': [],
    }
    if not os.path.exists(path):
        return result

    with open(path, 'r') as f:
        content = f.read()

    latest = re.search(r'## Latest Release\n(.*?)(?=\n## |\Z)', content, re.DOTALL)
    if latest:
        block = re.split(r'\n---\n', latest.group(1), maxsplit=1)[0]

        m = re.search(r'### Build:\s*(.+)', block)
        if m:
            result['build'] = m.group(1).strip()

        for key, pattern in [
            ('version', r'\*\*Version:\*\*\s*`?([^\s`\n]+)`?'),
            ('commit',  r'\*\*Commit:\*\*\s*`?([^\s`\n]+)`?'),
            ('tickets', r'\*\*Tickets Addressed:\*\*\s*(.+)'),
        ]:
            m = re.search(pattern, block)
            if m:
                result[key] = m.group(1).strip()

        m = re.search(r'#### Summary\n(.*?)(?=\n####|\Z)', block, re.DOTALL)
        if m:
            raw = re.sub(r'\*\*(.+?)\*\*', r'\1', m.group(1).strip())
            raw = re.sub(r'`(.+?)`', r'\1', raw)
            result['summary'] = raw.replace('\n', ' ')

    info = re.search(r'## Current Release Information\n(.*?)(?=\n## |\Z)', content, re.DOTALL)
    if info:
        block = info.group(1)
        pkg_sec = re.search(r'### Package Versions\n(.*?)(?=\n###|\Z)', block, re.DOTALL)
        if pkg_sec:
            for row in pkg_sec.group(1).splitlines():
                if not row.strip().startswith('|') or re.match(r'^\|[-| :]+\|$', row.strip()):
                    continue
                cells = [c.strip() for c in row.strip().strip('|').split('|')]
                if len(cells) >= 2 and cells[0].lower() not in ('package', ''):
                    result['packages'].append((cells[0], cells[1]))

        chk_sec = re.search(r'### Installer Checksums\n(.*?)(?=\n###|\Z)', block, re.DOTALL)
        if chk_sec:
            for row in chk_sec.group(1).splitlines():
                if not row.strip().startswith('|') or re.match(r'^\|[-| :]+\|$', row.strip()):
                    continue
                cells = [c.strip() for c in row.strip().strip('|').split('|')]
                if len(cells) >= 2 and cells[0].lower() not in ('file', ''):
                    result['checksums'].append((cells[0], cells[1]))

    return result


# ── Curses helpers ─────────────────────────────────────────────────────────────
_BAR_WIDTH = 30
_SPIN      = ['-', '\\', '|', '/']


def _bar_fill(phase: str) -> int:
    return {
        'copy':    int(_BAR_WIDTH * 0.28),
        'install': int(_BAR_WIDTH * 0.62),
        'cleanup': int(_BAR_WIDTH * 0.88),
        'done':    _BAR_WIDTH,
        'fail':    int(_BAR_WIDTH * 0.40),
    }.get(phase, 0)


def _wrap(text: str, width: int) -> list:
    words, lines, cur = text.split(), [], ''
    for word in words:
        cand = (cur + ' ' + word).lstrip()
        if len(cand) <= width:
            cur = cand
        else:
            if cur:
                lines.append(cur)
            cur = word
    if cur:
        lines.append(cur)
    return lines or ['']


def _divider(win, row: int, W: int, attr: int):
    try:
        win.addch(row, 0,     curses.ACS_LTEE, attr)
        win.hline(row, 1,     curses.ACS_HLINE | attr, W - 2)
        win.addch(row, W - 1, curses.ACS_RTEE, attr)
    except curses.error:
        pass


def _addstr(win, row: int, col: int, text: str, attr: int, max_col: int):
    """addstr clipped to max_col; silently ignores curses errors."""
    if col >= max_col:
        return
    try:
        win.addstr(row, col, text[:max_col - col], attr)
    except curses.error:
        pass


def _pkg_short(ver: str) -> str:
    """Strip date+hash+arch+rpm suffix from a package version string."""
    v = re.sub(r'-\d{8}[_\-][0-9a-f]{6,10}', '', ver)   # -20260225_a20257bb or -20260225-a20257bb
    v = re.sub(r'-[0-9a-f]{6,10}(?=\.x86_64|\.rpm|$)', '', v)  # bare -a20257bb
    v = re.sub(r'\.x86_64\.rpm$', '', v)
    v = re.sub(r'\.x86_64$', '', v)
    v = re.sub(r'\.rpm$', '', v)
    return v


# ── Main curses UI ─────────────────────────────────────────────────────────────
def run_installer_ui(installer: Installer, notes: dict) -> tuple:
    """
    Render the full curses progress screen while all nodes install in parallel.
    Returns (overall_ok: bool, all_errors: list[str]).
    """
    # ── Shared progress state ──────────────────────────────────────────────
    lock     = threading.Lock()
    progress: dict[str, Any] = {'_lock': lock}
    for ip in installer.hostips:
        progress[ip] = {'phase': 'pending', 'detail': '', 'errors': []}

    all_done = threading.Event()
    start_t  = time.monotonic()

    # ── Per-node threads ───────────────────────────────────────────────────
    threads = [
        threading.Thread(
            target=installer.install_node,
            args=(ip, progress),
            daemon=True,
        )
        for ip in installer.hostips
    ]
    for t in threads:
        t.start()

    def _waiter():
        for t in threads:
            t.join()
        all_done.set()

    threading.Thread(target=_waiter, daemon=True).start()

    # ── Pre-compute static content ─────────────────────────────────────────
    summary_lines = _wrap(notes.get('summary', ''), 100)
    pkgs          = notes.get('packages', [])
    n_nodes       = len(installer.hostips)

    # Scroll state for node viewport (mutable via list so closure can write)
    scroll        = [0]   # scroll[0] = index of first visible node

    # ── Curses draw loop ───────────────────────────────────────────────────
    def _draw(stdscr):
        try:
            curses.curs_set(0)
        except curses.error:
            pass
        curses.start_color()
        curses.use_default_colors()
        curses.init_pair(1, curses.COLOR_CYAN,    -1)
        curses.init_pair(2, curses.COLOR_GREEN,   -1)
        curses.init_pair(3, curses.COLOR_YELLOW,  -1)
        curses.init_pair(4, curses.COLOR_RED,     -1)
        curses.init_pair(5, curses.COLOR_BLUE,    -1)
        curses.init_pair(6, curses.COLOR_WHITE,   -1)
        curses.init_pair(7, curses.COLOR_MAGENTA, -1)

        C_BDR  = curses.color_pair(1)
        C_OK   = curses.color_pair(2) | curses.A_BOLD
        C_RUN  = curses.color_pair(3) | curses.A_BOLD
        C_FAIL = curses.color_pair(4) | curses.A_BOLD
        C_PEND = curses.color_pair(5)
        C_VAL  = curses.color_pair(5)
        C_LBL  = curses.color_pair(6)
        C_CLN  = curses.color_pair(7) | curses.A_BOLD
        C_HDR  = curses.color_pair(1) | curses.A_BOLD

        stdscr.nodelay(True)
        stdscr.timeout(100)
        frame      = 0
        done_at    = None   # monotonic time when all_done was first set
        COUNTDOWN  = 10

        while True:
            frame += 1
            term_r, term_c = stdscr.getmaxyx()
            W     = min(114, term_c)
            INNER = W - 4

            with lock:
                snap = {ip: dict(progress[ip]) for ip in installer.hostips}

            elapsed = int(time.monotonic() - start_t)
            runtime = f"{elapsed // 60:02d}:{elapsed % 60:02d}"

            # ── Height accounting ─────────────────────────────────────
            n_pkg_rows  = max(1, -(-len(pkgs) // 2))   # ceil(len/2)
            FIXED_ROWS  = (
                2              # border top + info row
                + 1            # divider
                + 2            # build row + tickets row
                + len(summary_lines)
                + 1            # divider
                + 1 + n_pkg_rows  # pkg label + pkg rows
                + 1            # divider
                + 1            # spacer before nodes
                + 1            # node header
                + 1            # spacer after last node
                + 1            # footer divider
                + 1            # footer
                + 1            # border bottom
            )
            # How many node rows fit in the terminal
            node_rows_avail = max(1, term_r - FIXED_ROWS)
            win_h = min(FIXED_ROWS + min(n_nodes, node_rows_avail), term_r)
            win_y = max(0, (term_r - win_h) // 2)
            win_x = max(0, (term_c - W)     // 2)

            # ── Auto-scroll: keep first running/pending node visible ───
            # Find the lowest-index node that isn't done/fail
            active_indices = [
                i for i, ip in enumerate(installer.hostips)
                if snap[ip]['phase'] not in ('done', 'fail')
            ]
            if active_indices:
                first_active = active_indices[0]
                # Scroll so first_active is near the top of the viewport,
                # but keep a 2-row context of already-completed nodes above it
                desired = max(0, first_active - 2)
                # Don't scroll past the point where the viewport would show
                # empty rows below the last node
                max_scroll = max(0, n_nodes - node_rows_avail)
                scroll[0] = min(desired, max_scroll)
            else:
                # All done — scroll to bottom so final states are visible
                scroll[0] = max(0, n_nodes - node_rows_avail)

            try:
                win = curses.newwin(win_h, W, win_y, win_x)
            except curses.error:
                time.sleep(0.1)
                continue

            win.erase()
            win.border()

            # ── Row 0: title ──────────────────────────────────────────
            title  = ' Odin Installer '
            rt_str = f' Runtime: {runtime} '
            _addstr(win, 0, 2,              title,  C_HDR, W - 2)
            _addstr(win, 0, W - len(rt_str) - 1, rt_str, C_HDR, W - 1)

            # ── Row 1: session info ───────────────────────────────────
            local_ip = installer.hostips[-1] if installer.hostips else '?'
            now_str  = datetime.datetime.now().strftime('%Y-%m-%d  %H:%M:%S')
            row, col = 1, 2
            for label, value in [
                ('Local IP: ', local_ip),
                ('   SSH Port: ', installer.port),
                ('   ', now_str),
            ]:
                _addstr(win, row, col, label, C_LBL, W - 2)
                col += len(label)
                _addstr(win, row, col, value, C_VAL, W - 2)
                col += len(value)

            # ── Divider ───────────────────────────────────────────────
            row = 2
            _divider(win, row, W, C_BDR)

            # ── Build info ────────────────────────────────────────────
            row += 1
            build_str = (
                f"Build: {notes.get('build','--')}   "
                f"Version: {notes.get('version','--')}   "
                f"Commit: {notes.get('commit','--')}"
            )
            _addstr(win, row, 2, build_str, C_VAL, W - 2)
            row += 1
            tickets = notes.get('tickets', '--')
            _addstr(win, row, 2, 'Tickets: ', C_LBL, W - 2)
            _addstr(win, row, 11, tickets, C_VAL, W - 2)

            # ── Summary ───────────────────────────────────────────────
            for sline in summary_lines:
                row += 1
                if row >= win_h - 1:
                    break
                _addstr(win, row, 2, sline, C_LBL, W - 2)

            # ── Divider ───────────────────────────────────────────────
            row += 1
            if row < win_h - 1:
                _divider(win, row, W, C_BDR)

            # ── Package versions ──────────────────────────────────────
            row += 1
            if row < win_h - 1:
                _addstr(win, row, 2, 'Packages', C_HDR, W - 2)
                COL_W  = INNER // 2
                NAM_W  = 22   # name column width
                VER_W  = COL_W - NAM_W - 2  # gap of 2 between name and version
                for i in range(0, len(pkgs), 2):
                    row += 1
                    if row >= win_h - 1:
                        break
                    for j, (pname, pver) in enumerate(pkgs[i:i+2]):
                        base = 2 + j * COL_W
                        v = re.sub(r'\.x86_64(?:\.rpm)?$|\.rpm$', '', pver.strip())
                        ver_rel = v[len(pname) + 1:] if v.startswith(pname + '-') else (v or '—')
                        _addstr(win, row, base,             f"{pname:<{NAM_W}}",        C_LBL, base + NAM_W)
                        _addstr(win, row, base + NAM_W + 2, f"{ver_rel:<{VER_W}}",      C_VAL, base + COL_W - 1)

            # ── Divider ───────────────────────────────────────────────
            row += 1
            if row < win_h - 1:
                _divider(win, row, W, C_BDR)

            # ── Spacer before nodes ───────────────────────────────────
            row += 1

            # ── Node header ───────────────────────────────────────────
            row += 1
            if row < win_h - 1:
                n_done_total = sum(
                    1 for ip in installer.hostips
                    if snap[ip]['phase'] in ('done', 'fail')
                )
                scroll_info = ''
                if n_nodes > node_rows_avail:
                    end_vis = min(scroll[0] + node_rows_avail, n_nodes)
                    scroll_info = f" [{scroll[0]+1}-{end_vis}/{n_nodes}]"
                hdr = (f"{'Node':<22}{'Phase':<12}"
                       f"{'-' * (_BAR_WIDTH + 2)}  Status{scroll_info}")
                _addstr(win, row, 2, hdr, C_HDR, W - 2)

            # ── Per-node bars (scrolling viewport) ────────────────────
            visible_ips = installer.hostips[scroll[0]:scroll[0] + node_rows_avail]
            for ip in visible_ips:
                row += 1
                if row >= win_h - 2:  # leave room for spacer
                    break
                phase  = snap[ip]['phase']
                detail = snap[ip]['detail']

                filled = _bar_fill(phase)
                # slight animation while running
                if phase in ('copy', 'install', 'cleanup'):
                    wobble = (frame // 3) % 3
                    filled = max(1, min(_BAR_WIDTH - 1, filled + wobble - 1))

                bar = '=' * filled + '-' * (_BAR_WIDTH - filled)

                if phase == 'done':
                    b_attr, p_attr, status = C_OK,   C_OK,   'DONE'
                elif phase == 'fail':
                    b_attr, p_attr, status = C_FAIL, C_FAIL, 'FAIL'
                elif phase == 'cleanup':
                    b_attr, p_attr, status = C_CLN,  C_CLN,  detail or 'CLEANUP'
                elif phase in ('copy', 'install'):
                    spin   = _SPIN[frame // 2 % len(_SPIN)]
                    b_attr = C_RUN
                    p_attr = C_RUN
                    status = f"{spin} {detail or phase.upper()}"
                else:
                    b_attr, p_attr, status = C_PEND, C_PEND, 'PENDING'

                col = 2
                _addstr(win, row, col, f"{ip:<22}",        C_LBL,  col + 22)
                col += 22
                _addstr(win, row, col, f"{phase.upper():<12}", p_attr, col + 12)
                col += 12
                _addstr(win, row, col, '[', C_BDR, col + 1)
                col += 1
                _addstr(win, row, col, bar, b_attr, col + _BAR_WIDTH)
                col += _BAR_WIDTH
                _addstr(win, row, col, '] ', C_BDR, col + 2)
                col += 2
                _addstr(win, row, col, status, p_attr, W - 2)

            # ── Spacer after nodes ────────────────────────────────────
            row += 1

            # ── Footer ────────────────────────────────────────────────
            row = win_h - 2
            if row > 0:
                _divider(win, row, W, C_BDR)
            row = win_h - 1
            if all_done.is_set():
                if done_at is None:
                    done_at = time.monotonic()
                secs_left = max(0, COUNTDOWN - int(time.monotonic() - done_at))
                n_fail = sum(1 for ip in installer.hostips
                             if snap[ip]['phase'] == 'fail')
                if n_fail:
                    footer = (f' Complete — {n_nodes - n_fail}/{n_nodes} nodes OK,'
                              f' {n_fail} failed — continuing in {secs_left}s ')
                    f_attr = C_FAIL | curses.A_REVERSE
                else:
                    footer = (f' Complete — {n_nodes}/{n_nodes} nodes OK'
                              f' — continuing in {secs_left}s ')
                    f_attr = C_OK | curses.A_REVERSE
            else:
                secs_left = COUNTDOWN
                n_done = sum(1 for ip in installer.hostips
                             if snap[ip]['phase'] in ('done', 'fail'))
                footer = (f' Installing — {n_done}/{n_nodes} nodes complete ')
                f_attr = C_RUN
            _addstr(win, row, max(1, (W - len(footer)) // 2), footer, f_attr, W - 1)

            win.refresh()

            ch = stdscr.getch()
            if all_done.is_set() and (ch != -1 or secs_left == 0):
                break
            if all_done.is_set():
                stdscr.timeout(200)

    if not sys.stdout.isatty():
        print('\033[33mWarning: not a TTY — curses UI unavailable; install running in background.\033[0m',
              flush=True)
        all_done.wait()
    else:
        try:
            curses.wrapper(_draw)
        except Exception as e:
            logging.error(f'curses error: {e}')
            print(f'\033[33mWarning: curses failed ({e}) — install running in background.\033[0m',
                  flush=True)
            all_done.wait()

    # ── Collect overall result ─────────────────────────────────────────────
    all_errors = []
    overall_ok = True
    for ip in installer.hostips:
        s = progress[ip]
        if s['phase'] != 'done':
            overall_ok = False
            all_errors.extend(s.get('errors', []))

    return overall_ok, all_errors, progress


# ── Entry point ────────────────────────────────────────────────────────────────
def main(**kwargs: dict) -> None:
    installer = Installer(kwargs)

    ok, errors = installer.check()
    if not ok:
        print('\033[91mError\033[0m : \033[33mPackage integrity check failed:\033[0m')
        for e in errors:
            print(f'  {e}')
        sys.exit(1)

    notes = parse_release_notes(os.path.join(os.getcwd(), RELEASE_NOTES))

    overall_ok, all_errors, progress = run_installer_ui(installer, notes)

    if not overall_ok:
        print('\n\033[91mInstallation failed on one or more nodes.\033[0m')
        for e in all_errors:
            print(f'  {e}')
        print('Log: odin_installer.INFO')
        sys.exit(1)

    print(f'\n  \033[92mInstall Complete\033[0m')
    print(f'  \033[92mLogs:\033[0m '
          f'/cohesity_logs/support-toolbox/odin_installer.INFO\n')
    print(f'  \033[34mEnvironment variables may not be active yet.\033[0m')
    print(f'  \033[34mTo activate:\033[0m \033[33msource ~/.bashrc\033[0m\n')
    print(f'  \033[34mPython updates may still be installing.\033[0m')
    print(f'  \033[34mRun\033[0m \033[33mhc_cli status\033[0m\033[34m and wait '
          f'for\033[0m \033[33mREADY\033[0m \033[34mbefore running '
          f'diagnostics or utils.\033[0m\n')


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('-p', '--port', default=2222)
    args, _ = parser.parse_known_args()
    signal(SIGINT,  sigint_handler)
    signal(SIGTSTP, sigtstp_handler)
    main(**vars(args))
