from core.controllers.ApplicationController import ApplicationController
from core.observers.ApplicationVersionObserver import ApplicationVersionObserver
from core.observers.ClientObserver import ClientObserver
from core.observers.ConnectionObserver import ConnectionObserver
from core.observers.InvoiceObserver import InvoiceObserver
from core.observers.ProfileObserver import ProfileObserver
from cli.ui import Spinner, label_ok, label_error, label_warn, label_connected, label_disconnect, progress_bar
from cli.helpers import sanitize_profile
import pprint

application_version_observer = ApplicationVersionObserver()
client_observer = ClientObserver()
connection_observer = ConnectionObserver()
invoice_observer = InvoiceObserver()
profile_observer = ProfileObserver()

application_version_observer.subscribe('downloading', lambda event: print(f'Downloading {ApplicationController.get(event.subject.application_code).name}, version {event.subject.version_number}...'))
application_version_observer.subscribe('download_progressing', lambda event: print(f'Current progress: {event.meta.get("progress"):.2f}%', flush=True, end='\r'))
application_version_observer.subscribe('downloaded', lambda event: print('\n'))

client_observer.subscribe('synchronizing', lambda event: print('Synchronizing...\n'))
client_observer.subscribe('updating', lambda event: print('Updating client...'))
client_observer.subscribe('update_progressing', lambda event: print(f'Current progress: {event.meta.get("progress"):.2f}%', flush=True, end='\r'))
client_observer.subscribe('updated', lambda event: print('\n'))

_spinner = None

def _on_connecting(event):
    global _spinner
    attempt = event.subject.get("attempt_count", "?")
    total   = event.subject.get("maximum_number_of_attempts", "?")
    _spinner = Spinner(f"Connecting... [{attempt}/{total}]")
    _spinner.start()

def _on_connected(event):
    global _spinner
    if _spinner:
        _spinner.stop()
        _spinner = None
    d = event.subject or {}
    label_connected(f"proxy={d.get('proxy_ip','?')}  real={d.get('real_ip','?')}  port={d.get('socks5_port','?')}")

def _on_disconnected(event):
    global _spinner
    if _spinner:
        _spinner.stop()
        _spinner = None
    d = event.subject or {}
    ip = d.get("ip", "?")
    label_disconnect(f"real={ip}")

def _on_error(event):
    global _spinner
    if _spinner:
        _spinner.stop()
        _spinner = None
    label_error(str(event.subject or "Unknown error"))

def _on_tor_bootstrapping(event):
    global _spinner
    _spinner = Spinner("Starting Tor...")
    _spinner.start()

def _on_tor_bootstrap_progressing(event):
    pct = int(event.meta.get("progress", 0))
    progress_bar(pct, 100, "Tor bootstrap")

def _on_tor_bootstrapped(event):
    global _spinner
    if _spinner:
        _spinner.stop()
        _spinner = None
    print()
    label_ok("Tor ready")

connection_observer.subscribe('connecting',                _on_connecting)
connection_observer.subscribe('connected',                 _on_connected)
connection_observer.subscribe('disconnected',              _on_disconnected)
connection_observer.subscribe('error',                     _on_error)
connection_observer.subscribe('tor_bootstrapping',         _on_tor_bootstrapping)
connection_observer.subscribe('tor_bootstrap_progressing', _on_tor_bootstrap_progressing)
connection_observer.subscribe('tor_bootstrapped',          _on_tor_bootstrapped)

invoice_observer.subscribe('retrieved', lambda event: print(f'\n{pprint.pp(event.subject)}\n'))
invoice_observer.subscribe('processing', lambda event: print('A payment has been detected and is being verified...\n'))
invoice_observer.subscribe('settled', lambda event: print('The payment has been successfully verified.\n'))

profile_observer.subscribe('created', lambda event: pprint.pp((sanitize_profile(event.subject), 'Created')))
profile_observer.subscribe('destroyed', lambda event: pprint.pp((sanitize_profile(event.subject), 'Destroyed')))
profile_observer.subscribe('disabled', lambda event: pprint.pp((sanitize_profile(event.subject), 'Disabled')) if event.meta.get('explicitly') else None)
profile_observer.subscribe('enabled', lambda event: pprint.pp((sanitize_profile(event.subject), 'Enabled')))