Welcome to BMO

def find_program(
    name: str, hints: T.List[T.Union[Path, str]] = [], recursive: bool = False
) -> T.Optional[str]:
    """where is a given binary"""
    for hint in hints:
        hint = Path(hint).resolve()
        if not hint.exists():
            continue
        for p in glob.glob(f"{hint}/**/{name}", recursive=recursive):
            prg = shutil.which(p)
            if prg is not None:
                return prg
    return shutil.which(name)

def is_windows(cygwin_is_windows: bool = True) -> bool:
    """Check if we are running on windows.

    Parameters
    ----------
        cygwin_is_windows : (default `True`). When set to `True`, consider cygwin as Windows.

    Returns
    -------
    `True` if on Windows, `False` otherwise.
    """
    _sys = system()
    if _sys[0].startswith("windows"):
        return True
    return cygwin_is_windows and _sys[1] == "cygwin"

def run_command(
    cmd: str, cwd: Path = Path.cwd(), silent: bool = False, stream: bool = True
) -> str:
    """Run a given command.

    Parameters
    ----------
    cmd : str
        cmd
    cwd : Path
        Current working directory.
    silent : bool
        If `True`, output is not printed onto console.
    stream : bool
        If `True` the output is printed line by line eagerly (as soon as a line is available)
        rather than all at once.

    Returns
    -------
    str

    Credits
    --------
    1. https://stackoverflow.com/questions/18421757/live-output-from-subprocess-command
    """
    logging.debug(f"Running `{cmd}` in {cwd}")
    p = subprocess.Popen(
        cmd.split(),
        cwd=cwd,
        text=True,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    lines = []
    if p.stdout is not None:
        for line in iter(p.stdout.readline, ""):
            if line is None:
                break
            line = line.rstrip()
            lines.append(f"> {line}")
            if stream and not silent:
                typer.echo(f"> {line}")

    output = "\n".join(lines)
    if not silent and not stream:
        typer.echo(f"> {output}")
    return output

def search_pat(pat, haystack):
    """Search for a pattern in haystack."""
    import re

    return re.search(pat, haystack, flags=re.IGNORECASE)

@app.command()
def weekly_email(
    to: str = typer.Option(...),
    config: str = typer.Option(..., callback=bmo.common.conf_callback, is_eager=True),
    notion_token: str = typer.Option(...),
    smtp_server: str = typer.Option(...),
    smtp_port: int = typer.Option(...),
    smtp_username: str = typer.Option(...),
    smtp_password: str = typer.Option(...),
    force: bool = typer.Option(False, "--force"),
):
    """This week in SubCom delivered to your INBOX."""
    if not notion_token:
        logging.error("Empty token. Add `--help` to usage.")
        return

    if datetime.today().weekday() != 0 and not force:
        logging.warning("Totay is not Monday. Use `--force` to override.")
        return

    notion = bmo.helpers.notion.Notion(notion_token)

    html = """<p>Greetings, puny Humans! I am <a
    href='https://github.com/SubconsciousCompute/bmo'>Subconscious BMO</a>. 
    I automate stuff. I found some stuff that happened at SubCom last week. Missing
    something? Let <a href='webmaster@subcom.tech'>webmaster@subcom.tech</a> know!</p>"""

    html += notion.weekly_update()
    html += "<p>-- <br /> 🎔 Subconscious BMO</p>"

    # create an email and send it. Don't send duplicates.
    emaildir = Path.home() / ".cache" / "bmo"
    h = bmo.common.hash256(html.encode())
    hfile = emaildir / h
    if hfile.exists():
        logging.warn("Email already sent.")
        return

    sender_email = smtp_username
    weekno = datetime.today().isocalendar()[1]
    subject = f"SubCom Weekly #{weekno}"
    envelope = Envelope(
        from_addr=(sender_email, "Subconscious BMO"),
        to_addr=to,
        subject=subject,
        html_body=html,
    )

    logging.info(f"Sending email to {to}")
    extra = ""
    if smtp_port == 587:
        extra = "starttls"
    envelope.send(smtp_server, smtp_port, sender_email, smtp_password, extra)
    # write the hash to disk.
    hfile.parent.mkdir(parents=True, exist_ok=True)
    hfile.write_text(h)