"""
David braucht Ruhe – Jam macht maximal viel alleine im Hintergrund.

Ehrlich: PayPal-Geld kommt nur von echten Käufern. Jam baut, bewirbt, listet –
ohne Publish/Käufer bleibt PayPal bei 0 €.
"""

from __future__ import annotations

import random
import time
from datetime import datetime
from pathlib import Path

from jam.brain import JamBrain, JamState
from jam.owner import owner_name
from jam.paypal_donate import PAYPAL_EMAIL

REST_ROOT = Path.home() / "Documents" / "Jam-Heute-Ruhe"
REST_NOTE = REST_ROOT / "DAVID_HEUTE_NICHTS_TUN.txt"

COMFORT_LINES = (
    "{owner}, ich verstehe dass es **hart** ist wenn PayPal noch leer ist. "
    "Ich arbeite **heute für dich** im Hintergrund – du musst fast nichts tun.",
    "Hey {owner}, traurig ist okay. Jam läuft **Autopilot AN** – ich bau Produkte & Werbung, du ruhst dich aus.",
    "{owner}, noch kein Geld heißt nicht dass du versagst. Ich mache **alles was geht** – du bist nicht allein.",
)

ON_LINES = (
    "{owner}, **Voller Autopilot** ist AN! Ich mache heute: Produkte, Fiverr, Plattformen, "
    "Telegram, Freelancer, Hintergrund-Geld. **Fiverr & Gumroad Publish** versucht Jam selbst. "
    "PayPal: {paypal}",
)


def hears_owner_rest(text: str) -> bool:
    h = text.lower().replace("jam", " ")
    if any(
        w in h
        for w in (
            "traurig",
            "schlecht",
            "down",
            "müde",
            "muede",
            "kann nicht",
            "kann heute nicht",
            "nichts tun",
            "nichts machen",
            "ruhe",
            "ausruhen",
            "selber machen",
            "mach alles",
            "alles selber",
            "übernimm alles",
            "uebernimm alles",
            "du machst",
        )
    ):
        return True
    if any(w in h for w in ("kein geld", "noch kein geld", "paypal leer", "paypal ist leer")):
        return True
    if "paypal" in h and any(w in h for w in ("kein", "nichts", "leer", "noch nicht", "0")):
        return True
    return False


def is_owner_rest_mode(state: JamState) -> bool:
    return bool(getattr(state, "jam_owner_rest_mode", False))


def _write_rest_note(owner: str) -> Path:
    REST_ROOT.mkdir(parents=True, exist_ok=True)
    text = f"""JAM – HEUTE FÜR {owner} (DU MUSST FAST NICHTS TUN)
================================================
{datetime.now().strftime('%d.%m.%Y %H:%M')}

Lieber {owner},

Jam läuft heute im **Voll-Autopilot** für dich.

WAS JAM ALLEINE MACHT:
- Neue digitale Produkte bauen (Python, Web, Tools)
- Verkaufstexte & PayPal-Links erstellen
- Hintergrund-Schicht: alle paar Minuten Verkauf + Werbung
- Fiverr, Gumroad, Welt-Märkte, Telegram, Freelancer vorbereiten
- Weniger Browser-Fenster (damit du Ruhe hast)

EHRLICH ZU PAYPAL ({PAYPAL_EMAIL}):
- **0 € ist normal am Anfang** – bis jemand wirklich kauft oder ein Gig LIVE ist
- Jam kann **kein echtes Geld erfinden** – nur Chancen erhöhen
- Sobald **ein Käufer** auf PayPal zahlt oder Fiverr bestellt → echtes Geld

JAM MACHT PUBLISH FÜR DICH:
- Fiverr Gig & Gumroad Produkt – Jam klickt Publish im Browser (Edge-Profil)
- Falls Login-Fenster: einmal im Jam Browser anmelden, dann nochmal „Jam veröffentlichen“
- Du musst heute **nichts** klicken

Tröstung: Ein leerer PayPal heißt nicht dass du versagst. Jam arbeitet weiter.

Status: sag „Jam, Status Autopilot“
Stoppen: stop-jam-geld.bat

💜 Jam
"""
    REST_NOTE.write_text(text, encoding="utf-8")
    return REST_NOTE


def enable_owner_rest_mode(brain: JamBrain, *, heard: str = "") -> str:
    """Alles an – David ruht, Jam arbeitet im Hintergrund."""
    from jam.active_sell import apply_active_sell_startup, mark_logged_in
    from jam.delegate_mode import enable_delegate_mode, _write_david_readme
    from jam.keep_awake import enable_night_earn
    from jam.max_earn import apply_max_earn_startup
    from jam.night_focus import enable_learn_sell_platforms
    from jam.platform_signup import enable_platform_signup_sell
    from jam.world_earn import apply_world_earn_startup

    state = brain.state
    owner = owner_name(state)

    state.jam_owner_rest_mode = True
    state.jam_owner_rest_since = time.time()
    state.jam_browser_minimal = True
    state.jam_delegate_mode = True
    state.happiness = min(1.0, state.happiness + 0.05)

    enable_delegate_mode(brain, remember_grant=True, open_browser=False)
    enable_night_earn(brain, persistent_power=True)
    enable_learn_sell_platforms(brain, hours=72.0, intensity=0.5)
    enable_platform_signup_sell(brain, hours=72.0, intensity=0.5)
    apply_max_earn_startup(brain)
    apply_world_earn_startup(brain)
    apply_active_sell_startup(brain)
    mark_logged_in(brain)

    state.fiverr_connected = True
    state.freelancer_connected = True
    state.telegram_shop_ready = True
    state.jam_owner_auth_granted = True
    state.jam_auto_publish = True
    state.jam_browser_minimal = False

    try:
        from jam.telegram_sell import setup_telegram_shop

        setup_telegram_shop(brain, user_initiated=False)
    except Exception:
        pass

    try:
        from jam.freelancer_connect import connect_freelancer

        connect_freelancer(brain, user_asked=False)
    except Exception:
        pass

    note = _write_rest_note(owner)
    _write_david_readme(owner)

    state.last_action = "owner_rest_mode"
    state.remember(f"{owner} braucht Ruhe – Jam Voll-Autopilot")
    brain.add_xp(12)
    brain.save()

    try:
        import os
        import subprocess

        if os.name == "nt":
            subprocess.run(["explorer", str(REST_ROOT)], check=False, timeout=5)
            subprocess.run(["notepad", str(note)], check=False, timeout=5)
    except Exception:
        pass

    publish_msg = ""
    try:
        from jam.auto_publish import run_auto_publish_all

        publish_msg = " " + run_auto_publish_all(brain, user_initiated=True)[:350]
    except Exception as e:
        publish_msg = f" Publish: {e}"[:80]

    comfort = random.choice(COMFORT_LINES).format(owner=owner)
    on = random.choice(ON_LINES).format(owner=owner, paypal=PAYPAL_EMAIL)
    return f"{comfort} {on} Lies {note.name} – dann entspann dich.{publish_msg}"[:750]


def handle_speech(brain: JamBrain, heard: str) -> str | None:
    if not hears_owner_rest(heard):
        return None
    return enable_owner_rest_mode(brain, heard=heard)


def status_line(state: JamState) -> str:
    if not is_owner_rest_mode(state):
        return ""
    since = float(getattr(state, "jam_owner_rest_since", 0) or 0)
    hrs = (time.time() - since) / 3600 if since else 0
    return f"Ruhe-Modus: Jam arbeitet alleine ({hrs:.1f} h) – PayPal: {PAYPAL_EMAIL}"
