#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
PONT OSC → EARMOTION (version web)
==================================

Reçoit de l'OSC en UDP (Max/MSP, Pure Data, TouchOSC, QLab, Reaper…) et le remet à
EarMotion ouvert dans un navigateur.

    python3 emt-osc-bridge.py            (--lang en : messages en anglais)

Puis, dans EarMotion : panneau « OSC » → « Connecter le pont ».

Options : --osc <port> (9130) · --web <port> (9131) · --sortie <hôte:port> (127.0.0.1:9132) ·
--lang fr|en · --origine <adresse> (une page de plus autorisée à recevoir l'OSC, ex.
--origine https://emt.monserveur.fr ; répétable, ou séparées par des virgules).

ORIGINES (10/10) : le pont ne transmet qu'aux pages qu'il connaît (earmotion.net, et le port 8000
local). Un EarMotion servi ailleurs — auto-hébergé, un serveur de test — se déclare par
`--origine`. Une page inconnue qui ouvre la fenêtre du pont n'en reçoit rien : la fenêtre le dit
(« origine non autorisée ») et le fait savoir à EarMotion, qui ne parle plus d'un pont absent.

LANGUE (10/10) : la console parle `--lang fr|en`, sinon la langue du système (LC_ALL, LC_MESSAGES,
LANG, puis la locale) — hors anglais, le français. La fenêtre parle la langue de l'interface
d'EarMotion, qui l'ouvre avec `&lang=fr|en` (à côté d'`origine=`) ; sans lui, celle du navigateur.

───────────────────────────────────────────────────────────────────────────────────────────
POURQUOI CE DÉTOUR PAR UNE PETITE FENÊTRE
───────────────────────────────────────────────────────────────────────────────────────────
Un navigateur n'ouvre pas de socket UDP : OSC ne peut pas lui arriver directement. Il faut
donc un pont local. Mais la voie évidente — la page https://earmotion.net ouvre elle-même une
WebSocket vers 127.0.0.1 — NE MARCHE PAS, et échoue de la pire façon.

Mesuré le 11/08/2026 sur Chrome 150 / macOS :
  · `new WebSocket('ws://127.0.0.1:9131')` depuis https://earmotion.net reste en `CONNECTING`
    INDÉFINIMENT. Aucun `error`, aucun `close`, aucun message en console. Même après un vrai
    clic. La connexion TCP touche le pont puis se referme sans qu'un octet HTTP soit envoyé.
  · `fetch(..., {targetAddressSpace:'local'})` échoue en 51 ms, sans jamais atteindre le pont.
  · `navigator.permissions.query({name:'local-network-access'})` répond `prompt` : l'accès au
    réseau local est désormais derrière une PERMISSION, et aucune invite ne s'est affichée.

D'où le détour, qui lui fonctionne : **EarMotion n'émet aucune requête vers le réseau local,
il ouvre une FENÊTRE.** Une navigation de premier niveau n'a jamais été soumise à cette
permission — sans quoi taper « localhost » dans la barre d'adresse serait impossible. Cette
fenêtre, servie par le pont, est donc de la MÊME ORIGINE que lui et lui parle librement ; elle
transmet ensuite à EarMotion par `postMessage`, qui traverse les origines sans rien demander.

    Max/MSP ──OSC/UDP──▶ pont ──WebSocket──▶ petite fenêtre ──postMessage──▶ earmotion.net
                                (même origine)              (origine vérifiée des deux côtés)

Conséquence à accepter : **la petite fenêtre doit rester ouverte.** La fermer coupe le pont.
C'est le prix de la permission qu'on n'a pas à demander.

───────────────────────────────────────────────────────────────────────────────────────────
CE QUE LE PONT NE SAIT PAS, ET NE DOIT PAS SAVOIR
───────────────────────────────────────────────────────────────────────────────────────────
Il ne connaît AUCUN verbe d'EarMotion. Il transmet `{adresse, arguments}` tels quels ; c'est
`msOscVersAction` (bloc pur `MS-OSC-PURE`) qui traduit, côté page, à partir du catalogue
d'actions. Ajouter un verbe au catalogue le rend joignable en OSC sans toucher à ce fichier.
C'est la même règle que pour l'API web : une seule liste de verbes dans tout le projet.

Bibliothèque standard uniquement — le projet n'a aucun gestionnaire de dépendances.
"""

import base64
import hashlib
import json
import locale
import os
import re
import socket
import struct
import sys
import threading
from urllib.parse import parse_qs, urlsplit

VERSION = '1.1'   # (10/10) --origine, et le refus dit à la page
PORT_OSC = 9130          # UDP, ce qu'écoute le pont
PORT_WEB = 9131          # TCP, la petite fenêtre ET sa WebSocket
SORTIE_DEFAUT = ('127.0.0.1', 9132)   # retour OSC vers le contrôleur

# Les pages autorisées à recevoir l'OSC. Une page qui n'y figure pas peut ouvrir la fenêtre du
# pont, mais celle-ci ne lui transmettra rien. `--origine` en ajoute (10/10).
PARENTS = ['https://earmotion.net', 'https://www.earmotion.net',
           'http://localhost:8000', 'http://127.0.0.1:8000']

# Une ORIGINE, et rien d'autre : schéma http(s), hôte, port facultatif — ni chemin, ni requête. C'est la forme que
# le navigateur donne à `location.origin` et que `postMessage` compare ; une adresse avec un chemin n'y serait
# jamais égale, et le refus paraîtrait inexplicable.
ORIGINE_RE = re.compile(r'^https?://[A-Za-z0-9.\-]+(:\d{1,5})?$|^https?://\[[0-9A-Fa-f:.]+\](:\d{1,5})?$')


def origine_normale(o):
    """`https://Hote.fr/` → `https://hote.fr` ; None si ce n'est pas une origine."""
    o = (o or '').strip().rstrip('/')
    if not ORIGINE_RE.match(o):
        return None
    schema, _, reste = o.partition('://')
    return schema.lower() + '://' + reste.lower()

GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'

clients = []
clients_lock = threading.Lock()
compteur = {'recus': 0}

# ── LES TEXTES DE LA CONSOLE, en français (la source) et en anglais (10/10) ──────────────────────
# Toute autre langue retombe sur le français, comme l'interface d'EarMotion.
TEXTES = {
    'fr': {
        'refus': '  refus : origine « %s »',
        'absente': 'absente',
        'connectee': '  fenêtre connectée',
        'fermee': '  fenêtre fermée',
        'option': 'option inconnue : ',
        'lang_invalide': 'langue inconnue : %s (fr ou en)',
        'port_web': 'Impossible d\'écouter sur le port %d : %s',
        'autre_pont': 'Un autre pont tourne déjà ? Sinon : --web <autre port>',
        'port_osc': 'Impossible d\'écouter l\'OSC sur le port %d : %s',
        'titre': '┌─ Pont OSC EarMotion %s',
        'entrant': '│  OSC/UDP entrant     : %d',
        'retour': '│  Retour OSC          : %s:%d',
        'fenetre': '│  Fenêtre du pont     : http://127.0.0.1:%d',
        'mode_emploi': '└─ Dans EarMotion : panneau « OSC » → Connecter le pont.  (Ctrl-C pour arrêter)',
        'arrete': '\nPont arrêté.',
        'origine_invalide': 'origine illisible : %s (attendu : https://hôte ou http://hôte:port, sans chemin)',
        'origines': '│  Pages autorisées    : %s',
        'page_refusee': '  fenêtre ouverte par une page non autorisée : %s — relancez le pont avec --origine %s',
    },
    'en': {
        'refus': '  refused: origin "%s"',
        'absente': 'missing',
        'connectee': '  window connected',
        'fermee': '  window closed',
        'option': 'unknown option: ',
        'lang_invalide': 'unknown language: %s (fr or en)',
        'port_web': 'Cannot listen on port %d: %s',
        'autre_pont': 'Is another bridge already running? Otherwise: --web <other port>',
        'port_osc': 'Cannot listen for OSC on port %d: %s',
        'titre': '┌─ EarMotion OSC bridge %s',
        'entrant': '│  Incoming OSC/UDP    : %d',
        'retour': '│  OSC feedback        : %s:%d',
        'fenetre': '│  Bridge window       : http://127.0.0.1:%d',
        'mode_emploi': '└─ In EarMotion: "OSC" panel → Connect the bridge.  (Ctrl-C to stop)',
        'arrete': '\nBridge stopped.',
        'origine_invalide': 'unreadable origin: %s (expected: https://host or http://host:port, no path)',
        'origines': '│  Allowed pages       : %s',
        'page_refusee': '  window opened by a page that is not allowed: %s — restart the bridge with --origine %s',
    },
}
USAGE_EN = """EARMOTION OSC BRIDGE (web version)
Receives OSC over UDP (Max/MSP, Pure Data, TouchOSC, QLab, Reaper…) and hands it to EarMotion
open in a browser.

    python3 emt-osc-bridge.py [--osc 9130] [--web 9131] [--sortie 127.0.0.1:9132] [--lang fr|en]
                              [--origine https://my-server.org]

Then, in EarMotion: "OSC" panel → "Connect the bridge". Keep the small bridge window open:
closing it cuts the bridge.

--origine adds a page allowed to receive the OSC (an EarMotion served elsewhere than
earmotion.net: self-hosted, a test server). It can be repeated, or take a comma-separated list.
A page that is not allowed receives nothing: the bridge window says "origin not allowed"."""


def langue_systeme():
    """La langue du système : variables d'environnement, puis la locale. 'en' ou 'fr'."""
    for v in ('LC_ALL', 'LC_MESSAGES', 'LANG', 'LANGUAGE'):
        x = os.environ.get(v, '')
        if x and x not in ('C', 'POSIX') and not x.startswith('C.'):
            return 'en' if x.lower().startswith('en') else 'fr'
    try:
        x = (locale.getlocale()[0] or '')
    except Exception:
        x = ''
    return 'en' if x.lower().startswith('en') else 'fr'


LANGUE = {'v': 'fr'}


def tx(cle):
    return TEXTES.get(LANGUE['v'], TEXTES['fr']).get(cle, TEXTES['fr'][cle])


# ═══════════════════════════════════════════════════════════════════════════════════════════
#  OSC
# ═══════════════════════════════════════════════════════════════════════════════════════════

def _chaine(buf, i):
    """Chaîne OSC : terminée par un zéro, puis alignée sur 4 octets."""
    fin = buf.index(b'\0', i)
    return buf[i:fin].decode('utf-8', 'replace'), (fin + 4) & ~3


def osc_parse(data):
    """Rend [(adresse, [arguments])]. Traverse les bundles."""
    if data[:8] == b'#bundle\0':
        out, i = [], 16
        while i + 4 <= len(data):
            (taille,) = struct.unpack_from('>i', data, i)
            i += 4
            if taille <= 0 or i + taille > len(data):
                break
            out.extend(osc_parse(data[i:i + taille]))
            i += taille
        return out
    try:
        addr, i = _chaine(data, 0)
        if not addr.startswith('/'):
            return []
        args = []
        if i < len(data) and data[i:i + 1] == b',':
            tags, i = _chaine(data, i)
            for t in tags[1:]:
                if t == 'i':
                    args.append(struct.unpack_from('>i', data, i)[0]); i += 4
                elif t == 'f':
                    args.append(round(struct.unpack_from('>f', data, i)[0], 6)); i += 4
                elif t == 'd':
                    args.append(struct.unpack_from('>d', data, i)[0]); i += 8
                elif t == 'h':
                    args.append(struct.unpack_from('>q', data, i)[0]); i += 8
                elif t in 'sS':
                    s, i = _chaine(data, i); args.append(s)
                elif t == 'b':
                    (n,) = struct.unpack_from('>i', data, i)
                    i += 4 + ((n + 3) & ~3)
                    args.append(None)
                elif t == 'T':
                    args.append(True)
                elif t == 'F':
                    args.append(False)
                elif t in 'NI':
                    args.append(None)
        return [(addr, args)]
    except Exception:
        return []


def osc_build(addr, args):
    # ⚠️ Le reste modulo 4 est repris modulo 4. Sans le second `% 4`, une chaîne DÉJÀ alignée
    # reçoit quatre octets de trop et le lecteur d'en face cherche l'argument suivant au
    # mauvais endroit : toute adresse de longueur multiple de 4 sort vide. Vu, et corrigé.
    def pad(b):
        return b + b'\0' * ((4 - len(b) % 4) % 4)
    tete = pad(addr.encode('utf-8') + b'\0')
    tags, corps = ',', b''
    for a in args:
        if isinstance(a, bool):
            tags += 'T' if a else 'F'
        elif isinstance(a, int):
            tags += 'i'; corps += struct.pack('>i', a)
        elif isinstance(a, float):
            tags += 'f'; corps += struct.pack('>f', a)
        else:
            tags += 's'; corps += pad(str(a).encode('utf-8') + b'\0')
    return tete + pad(tags.encode() + b'\0') + corps


# ═══════════════════════════════════════════════════════════════════════════════════════════
#  La petite fenêtre — servie par le pont, donc de sa propre origine
# ═══════════════════════════════════════════════════════════════════════════════════════════

def page(port_web, port_osc):
    return """<!doctype html>
<html lang="fr"><head><meta charset="utf-8"><title>Pont OSC — EarMotion</title>
<meta name="viewport" content="width=device-width,initial-scale=1">
<style>
 :root { color-scheme: dark; }
 body { margin:0; padding:18px; background:#111; color:#e8e8e8;
        font:13px/1.5 -apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif; }
 h1 { font-size:13px; letter-spacing:.14em; text-transform:uppercase; opacity:.55;
      margin:0 0 14px; font-weight:600; }
 .etat { display:flex; align-items:center; gap:9px; font-size:15px; margin-bottom:14px; }
 .pastille { width:9px; height:9px; border-radius:50%; background:#666; flex:none; }
 .on .pastille { background:#4caf50; }
 .off .pastille { background:#c0392b; }
 dl { display:grid; grid-template-columns:auto 1fr; gap:5px 14px; margin:0; font-size:12px; }
 dt { opacity:.5; } dd { margin:0; font-variant-numeric:tabular-nums; }
 code { background:#1e1e1e; padding:1px 5px; border-radius:3px; font-size:11px; }
 .note { margin-top:16px; font-size:11.5px; opacity:.55; line-height:1.5; }
</style></head><body>
<h1 data-t="titre">Pont OSC</h1>
<div class="etat" id="etat"><span class="pastille"></span><span id="etatTexte">connexion…</span></div>
<dl>
  <dt data-t="ecoute">Écoute</dt><dd>OSC/UDP <code>__PORT_OSC__</code></dd>
  <dt data-t="recus">Reçus</dt><dd id="nb">0</dd>
  <dt data-t="dernier">Dernier</dt><dd id="dernier">—</dd>
</dl>
<p class="note" data-t="note">Garder cette fenêtre ouverte : la fermer coupe le pont.</p>
<script>
(function () {
  var PARENTS = __PARENTS__;
  var p = new URLSearchParams(location.search);
  var cible = p.get('origine') || '';
  // (10/10) LA LANGUE : `lang` (fr | en) que pose EarMotion en ouvrant la fenêtre, sinon celle du navigateur ;
  // hors anglais, le français (la source).
  var T = {
    fr: { titre: 'Pont OSC', doc: 'Pont OSC — EarMotion', connexion: 'connexion…', ecoute: 'Écoute', recus: 'Reçus',
          dernier: 'Dernier', note: 'Garder cette fenêtre ouverte : la fermer coupe le pont.',
          ouvrir: 'ouvrir depuis EarMotion', connecte: 'connecté à {cible}', arrete: 'pont arrêté', injoignable: 'pont injoignable',
          refusee: 'origine non autorisée : {cible} — relancez le pont avec --origine {cible}' },
    en: { titre: 'OSC bridge', doc: 'OSC bridge — EarMotion', connexion: 'connecting…', ecoute: 'Listening', recus: 'Received',
          dernier: 'Last', note: 'Keep this window open: closing it cuts the bridge.',
          ouvrir: 'open from EarMotion', connecte: 'connected to {cible}', arrete: 'bridge stopped', injoignable: 'bridge unreachable',
          refusee: 'origin not allowed: {cible} — restart the bridge with --origine {cible}' }
  };
  var l = (p.get('lang') || '').toLowerCase();
  if (l !== 'fr' && l !== 'en') l = /^en\\b/i.test(navigator.language || '') ? 'en' : 'fr';
  function tr(k, v) { var s = T[l][k] || T.fr[k] || k; return v ? s.split('{cible}').join(v) : s; }
  document.documentElement.lang = l;
  document.title = tr('doc');
  Array.prototype.forEach.call(document.querySelectorAll('[data-t]'), function (e) { e.textContent = tr(e.getAttribute('data-t')); });
  document.getElementById('etatTexte').textContent = tr('connexion');

  var eEtat = document.getElementById('etat'), eTexte = document.getElementById('etatTexte');
  var eNb = document.getElementById('nb'), eDernier = document.getElementById('dernier');
  var n = 0;
  function dire(cls, txt) { eEtat.className = 'etat ' + cls; eTexte.textContent = txt; }

  // La fenêtre ne parle qu'à une page déclarée. Sans ça, n'importe quel site pourrait
  // l'ouvrir et se faire livrer l'OSC de la machine.
  // (10/10) UNE PAGE INCONNUE QUI L'OUVRE N'EST PLUS ACCUEILLIE PAR « ouvrir depuis EarMotion » — elle venait
  //  justement d'être ouverte par EarMotion, servi ailleurs qu'earmotion.net. La fenêtre dit « origine non
  //  autorisée » et le fait savoir à la page (refus SANS données : aucun OSC ne part, aucune WebSocket ne s'ouvre),
  //  qui le relaie au lieu de croire le pont absent.
  if (cible && PARENTS.indexOf(cible) < 0) {
    dire('off', tr('refusee', cible));
    try { if (window.opener) window.opener.postMessage({ emtPont: 'refus', raison: 'origine', version: '__VERSION__' }, cible); } catch (e) {}
    return;
  }
  if (!cible) { dire('off', tr('ouvrir')); return; }

  var ws = new WebSocket((location.protocol === 'https:' ? 'wss://' : 'ws://') + location.host);
  ws.onopen = function () {
    dire('on', tr('connecte', cible.replace(/^https?:\\/\\//, '')));
    if (window.opener) window.opener.postMessage({ emtPont: 'pret', version: '__VERSION__' }, cible);
  };
  ws.onclose = function () { dire('off', tr('arrete')); };
  ws.onerror = function () { dire('off', tr('injoignable')); };
  ws.onmessage = function (ev) {
    var m; try { m = JSON.parse(ev.data); } catch (e) { return; }
    if (!m || m.t !== 'osc') return;
    n++; eNb.textContent = n; eDernier.textContent = m.addr;
    if (window.opener) window.opener.postMessage({ emtPont: 'osc', addr: m.addr, args: m.args }, cible);
  };

  // Retour : EarMotion renvoie son état vers le contrôleur OSC.
  window.addEventListener('message', function (ev) {
    if (ev.origin !== cible || ev.source !== window.opener) return;
    var d = ev.data;
    if (!d || d.emtPont !== 'sortie' || !d.addr) return;
    if (ws.readyState === 1) ws.send(JSON.stringify({ t: 'osc', addr: d.addr, args: d.args || [] }));
  });

  window.addEventListener('pagehide', function () { try { ws.close(); } catch (e) {} });
}());
</script></body></html>""" \
        .replace('__PORT_OSC__', str(port_osc)) \
        .replace('__PARENTS__', json.dumps(PARENTS)) \
        .replace('__VERSION__', VERSION)


# ═══════════════════════════════════════════════════════════════════════════════════════════
#  WebSocket (RFC 6455, le strict nécessaire)
# ═══════════════════════════════════════════════════════════════════════════════════════════

def ws_frame(charge):
    b = charge.encode('utf-8')
    n = len(b)
    if n < 126:
        return struct.pack('>BB', 0x81, n) + b
    if n < 65536:
        return struct.pack('>BBH', 0x81, 126, n) + b
    return struct.pack('>BBQ', 0x81, 127, n) + b


def ws_lire(sock):
    def recevoir(n):
        b = b''
        while len(b) < n:
            m = sock.recv(n - len(b))
            if not m:
                return None
            b += m
        return b
    t = recevoir(2)
    if not t:
        return None
    op, masque, n = t[0] & 0x0F, t[1] & 0x80, t[1] & 0x7F
    if n == 126:
        d = recevoir(2)
        if not d: return None
        n = struct.unpack('>H', d)[0]
    elif n == 127:
        d = recevoir(8)
        if not d: return None
        n = struct.unpack('>Q', d)[0]
    if n > (1 << 20):
        return None
    cle = recevoir(4) if masque else b'\0\0\0\0'
    if cle is None:
        return None
    corps = recevoir(n) if n else b''
    if corps is None:
        return None
    if masque:
        corps = bytes(c ^ cle[i % 4] for i, c in enumerate(corps))
    return op, corps


def servir(sock, port_web, port_osc, sortie, cible_udp):
    """Une connexion : soit la page, soit une WebSocket."""
    inscrit = False
    try:
        requete = b''
        while b'\r\n\r\n' not in requete:
            m = sock.recv(4096)
            if not m:
                return
            requete += m
            if len(requete) > 16384:
                return
        lignes = requete.decode('latin-1').split('\r\n')
        entetes = {}
        for l in lignes[1:]:
            if ':' in l:
                k, v = l.split(':', 1)
                entetes[k.strip().lower()] = v.strip()

        if entetes.get('upgrade', '').lower() != 'websocket':
            # (10/10) Le terminal le dit aussi : une page non autorisée vient d'ouvrir la fenêtre, et comment l'admettre.
            try:
                chemin = lignes[0].split(' ')[1] if len(lignes[0].split(' ')) > 1 else '/'
                demandee = (parse_qs(urlsplit(chemin).query).get('origine') or [''])[0]
                if demandee and demandee not in PARENTS:
                    # N'importe quelle page peut ouvrir cette fenêtre avec n'importe quel texte : on n'imprime que du
                    # visible (pas de séquence d'échappement envoyée au terminal), et court.
                    aff = ''.join(c for c in demandee[:120] if c.isprintable())
                    print(tx('page_refusee') % (aff, aff))
            except Exception:
                pass
            corps = page(port_web, port_osc).encode('utf-8')
            sock.sendall(b'HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\n'
                         b'Cache-Control: no-store\r\n'
                         b'Content-Length: ' + str(len(corps)).encode() + b'\r\n'
                         b'Connection: close\r\n\r\n' + corps)
            return

        origine = entetes.get('origin', '')
        cle = entetes.get('sec-websocket-key', '')
        # La fenêtre du pont est servie par le pont : sa WebSocket est de la MÊME origine.
        # Toute autre origine est refusée — c'est la seule défense qui tienne, et le
        # navigateur pose `Origin` lui-même : une page ne peut pas mentir dessus.
        miennes = {'http://127.0.0.1:%d' % port_web, 'http://localhost:%d' % port_web}
        if not cle or origine not in miennes:
            print(tx('refus') % (origine or tx('absente')))
            sock.sendall(b'HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n')
            return
        accept = base64.b64encode(hashlib.sha1((cle + GUID).encode()).digest()).decode()
        sock.sendall(('HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\n'
                      'Connection: Upgrade\r\nSec-WebSocket-Accept: ' + accept + '\r\n\r\n').encode())
        with clients_lock:
            clients.append(sock)
        inscrit = True
        print(tx('connectee'))

        while True:
            r = ws_lire(sock)
            if r is None:
                break
            op, corps = r
            if op == 8:
                break
            if op == 9:
                sock.sendall(struct.pack('>BB', 0x8A, len(corps)) + corps)
            elif op == 1:
                try:
                    m = json.loads(corps.decode('utf-8'))
                except Exception:
                    continue
                if isinstance(m, dict) and m.get('t') == 'osc' and m.get('addr'):
                    sortie.sendto(osc_build(str(m['addr']), m.get('args') or []), cible_udp)
    except Exception:
        pass
    finally:
        with clients_lock:
            if sock in clients:
                clients.remove(sock)
        try:
            sock.close()
        except Exception:
            pass
        if inscrit:
            print(tx('fermee'))


def diffuser(obj):
    trame = ws_frame(json.dumps(obj, ensure_ascii=False))
    with clients_lock:
        morts = []
        for c in clients:
            try:
                c.sendall(trame)
            except Exception:
                morts.append(c)
        for c in morts:
            clients.remove(c)


# ═══════════════════════════════════════════════════════════════════════════════════════════

def main(argv):
    port_osc, port_web = PORT_OSC, PORT_WEB
    cible_udp = SORTIE_DEFAUT
    # La langue d'abord (elle décide de ce que disent les erreurs d'options) : --lang, sinon le système.
    LANGUE['v'] = langue_systeme()
    for j in range(1, len(argv) - 1):
        if argv[j] == '--lang':
            if argv[j + 1] in ('fr', 'en'):
                LANGUE['v'] = argv[j + 1]
            else:
                print(tx('lang_invalide') % argv[j + 1]); return 2
    i = 1
    while i < len(argv):
        a = argv[i]
        if a in ('-h', '--aide', '--help'):
            print(USAGE_EN if LANGUE['v'] == 'en' else __doc__)
            return 0
        if a == '--lang' and i + 1 < len(argv):
            i += 2; continue
        if a == '--osc' and i + 1 < len(argv):
            port_osc = int(argv[i + 1]); i += 2; continue
        if a == '--web' and i + 1 < len(argv):
            port_web = int(argv[i + 1]); i += 2; continue
        if a == '--sortie' and i + 1 < len(argv):
            h, _, p = argv[i + 1].partition(':')
            cible_udp = (h or '127.0.0.1', int(p or 9132)); i += 2; continue
        if a == '--origine' and i + 1 < len(argv):
            # (10/10) Une page de plus autorisée à recevoir l'OSC (EarMotion auto-hébergé, serveur de test).
            for brute in argv[i + 1].split(','):
                if not brute.strip():
                    continue
                o = origine_normale(brute)
                if not o:
                    print(tx('origine_invalide') % brute.strip()); return 2
                if o not in PARENTS:
                    PARENTS.append(o)
            i += 2; continue
        print(tx('option') + a); return 2

    sortie = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    try:
        # 127.0.0.1 et jamais 0.0.0.0 : le pont ne s'expose pas au réseau.
        srv.bind(('127.0.0.1', port_web))
    except OSError as e:
        print(tx('port_web') % (port_web, e))
        print(tx('autre_pont'))
        return 1
    srv.listen(8)

    udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    udp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    try:
        udp.bind(('0.0.0.0', port_osc))
    except OSError as e:
        print(tx('port_osc') % (port_osc, e))
        return 1

    def accepter():
        while True:
            try:
                s, _ = srv.accept()
            except OSError:
                return
            threading.Thread(target=servir,
                             args=(s, port_web, port_osc, sortie, cible_udp),
                             daemon=True).start()
    threading.Thread(target=accepter, daemon=True).start()

    print(tx('titre') % VERSION)
    print(tx('entrant') % port_osc)
    print(tx('retour') % cible_udp)
    print(tx('fenetre') % port_web)
    print(tx('origines') % ', '.join(PARENTS))
    print(tx('mode_emploi'))

    while True:
        data, _ = udp.recvfrom(65535)
        for addr, args in osc_parse(data):
            compteur['recus'] += 1
            diffuser({'t': 'osc', 'addr': addr, 'args': args})


if __name__ == '__main__':
    try:
        sys.exit(main(sys.argv) or 0)
    except KeyboardInterrupt:
        print(tx('arrete'))
