#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
md_to_bpmn.py
=============
Wandelt eine einfache Markdown-Prozessbeschreibung in eine standardkonforme
BPMN-2.0-XML-Datei um (OMG-Standard, offen dokumentiert, kein Bezug zu
internen PICTURE-UUIDs).

Wird bei einem Arbeitsschritt "Verantwortlicher: Aufgabe" geschrieben
(z. B. "S2 Task: Sachbearbeiter: Antrag prüfen"), erkennt das Skript den
Teil vor dem ersten Doppelpunkt als Verantwortlichen und erzeugt daraus
automatisch Swimlanes (Pool + Lanes). Ohne diese Angabe entsteht wie bisher
ein Diagramm ohne Lanes.

Unterstützt neben Task/Gateway/Start/Ende auch die übrigen für PICTURE
relevanten Elemente aus Elementkatalog.md (Aufgaben-Varianten, typisierte
Ereignisse, ereignisbasiertes Gateway, Datenobjekt/-speicher, Gruppe sowie
geschlossene Pools mit Nachrichtenflüssen). Siehe Anleitung.md für die
vollständige Syntax.

Aufruf:
    python3 md_to_bpmn.py prozess.md ausgabe.bpmn
"""
import argparse
import math
import re
import sys
import xml.etree.ElementTree as ET
from xml.dom import minidom
from collections import defaultdict

# ---------------------------------------------------------------------------
# 1) DSL
# ---------------------------------------------------------------------------
SIMPLE_TYPE_ALIASES = {
    'start': 'StartEvent', 'startereignis': 'StartEvent',
    'ende': 'EndEvent', 'end': 'EndEvent', 'endereignis': 'EndEvent',
    'zwischenereignis': 'IntermediateEvent', 'intermediate': 'IntermediateEvent',

    'task': 'Task', 'aufgabe': 'Task',
    'manuelle aufgabe': 'ManualTask', 'manual task': 'ManualTask', 'manualtask': 'ManualTask',
    'user aufgabe': 'UserTask', 'user task': 'UserTask', 'usertask': 'UserTask',
    'service aufgabe': 'ServiceTask', 'service task': 'ServiceTask', 'servicetask': 'ServiceTask',
    'script aufgabe': 'ScriptTask', 'script task': 'ScriptTask', 'scripttask': 'ScriptTask',
    'geschäftsregel aufgabe': 'BusinessRuleTask', 'geschaeftsregel aufgabe': 'BusinessRuleTask',
    'business rule task': 'BusinessRuleTask', 'businessruletask': 'BusinessRuleTask',
    'sendeaufgabe': 'SendTask', 'send task': 'SendTask', 'aufgabe sendend': 'SendTask', 'sendtask': 'SendTask',
    'empfangsaufgabe': 'ReceiveTask', 'receive task': 'ReceiveTask', 'aufgabe empfangend': 'ReceiveTask',
    'receivetask': 'ReceiveTask',

    'gateway xor': 'XorGateway', 'xor': 'XorGateway', 'entscheidung': 'XorGateway',
    'gateway or': 'OrGateway', 'gateway oder': 'OrGateway', 'or': 'OrGateway', 'oder': 'OrGateway',
    'gateway and': 'AndGateway', 'gateway und': 'AndGateway', 'and': 'AndGateway',
    'und': 'AndGateway', 'parallel': 'AndGateway',
    'gateway ereignisbasiert': 'EventBasedGateway', 'gateway ebg': 'EventBasedGateway',
    'ereignisbasierte verzweigung': 'EventBasedGateway', 'event based gateway': 'EventBasedGateway',

    'hinweis': 'TextAnnotation', 'note': 'TextAnnotation', 'anmerkung': 'TextAnnotation',
    'datenobjekt': 'DataObject', 'dokument': 'DataObject', 'data object': 'DataObject',
    'datenspeicher': 'DataStore', 'data store': 'DataStore',
    'gruppe': 'Group', 'group': 'Group',

    'teilprozess': 'SubProcess', 'subprocess': 'SubProcess',
    'geschlossener teilprozess': 'SubProcess',
    'aufruf': 'CallActivity', 'aufrufelement': 'CallActivity', 'aufruf element': 'CallActivity',
    'call activity': 'CallActivity', 'callactivity': 'CallActivity',
}

EVENT_USAGE_WORDS = {
    'start': 'StartEvent', 'startereignis': 'StartEvent',
    'zwischenereignis': 'IntermediateEvent', 'intermediate': 'IntermediateEvent',
    'ende': 'EndEvent', 'end': 'EndEvent', 'endereignis': 'EndEvent',
}
EVENT_KIND_WORDS = {
    'nachricht': 'message', 'message': 'message',
    'zeit': 'timer', 'timer': 'timer',
    'eskalation': 'escalation', 'escalation': 'escalation',
    'bedingung': 'conditional', 'condition': 'conditional', 'conditional': 'conditional',
    'link': 'link',
    'fehler': 'error', 'error': 'error',
    'signal': 'signal',
    'terminierung': 'terminate', 'terminate': 'terminate', 'termination': 'terminate',
}
EVENT_DIRECTION_WORDS = {
    'sendend': 'throw', 'send': 'throw', 'werfend': 'throw', 'throw': 'throw',
    'empfangend': 'catch', 'receive': 'catch', 'fangend': 'catch', 'catch': 'catch',
}
EVENT_DEFINITION_TAG = {
    'message': 'messageEventDefinition', 'timer': 'timerEventDefinition',
    'escalation': 'escalationEventDefinition', 'conditional': 'conditionalEventDefinition',
    'link': 'linkEventDefinition', 'error': 'errorEventDefinition',
    'signal': 'signalEventDefinition', 'terminate': 'terminateEventDefinition',
}

UNCONNECTED_TYPES = {'TextAnnotation', 'DataObject', 'DataStore', 'Group'}

# Für die Verteilung mehrerer Anschlusspunkte (Modellierregel 4) muss die tatsächliche
# Kontur bekannt sein: ein Punkt auf dem rechteckigen Begrenzungsrahmen liegt bei einer
# Raute (Gateway) oder einem Kreis (Ereignis) sonst neben der sichtbaren Form.
SHAPE_KIND = {
    'StartEvent': 'circle', 'EndEvent': 'circle', 'IntermediateEvent': 'circle',
    'XorGateway': 'diamond', 'OrGateway': 'diamond', 'AndGateway': 'diamond',
    'EventBasedGateway': 'diamond',
}

DEFAULT_SIZE = {
    'StartEvent': (36, 36), 'EndEvent': (36, 36), 'IntermediateEvent': (36, 36),
    'XorGateway': (50, 50), 'OrGateway': (50, 50), 'AndGateway': (50, 50), 'EventBasedGateway': (50, 50),
    'Task': (100, 80), 'ManualTask': (100, 80), 'UserTask': (100, 80), 'ServiceTask': (100, 80),
    'ScriptTask': (100, 80), 'BusinessRuleTask': (100, 80), 'SendTask': (100, 80), 'ReceiveTask': (100, 80),
    'SubProcess': (100, 80), 'CallActivity': (100, 80),
    'TextAnnotation': (160, 60), 'DataObject': (36, 50), 'DataStore': (50, 50), 'Group': (220, 140),
}

STEP_RE = re.compile(
    r'^(?P<id>[A-Za-z0-9_.\-]+)\s+'
    r'(?P<typewords>[A-Za-zÄÖÜäöüß]+(?:\s+[A-Za-zÄÖÜäöüß]+){0,7})'
    r'\s*:\s*(?P<label>.*)$',
    re.IGNORECASE,
)
ARROW_RE = re.compile(r'^\s*(?:(?P<label>.+?)\s*)?->\s*(?P<target>\S+)\s*$')
MSGFLOW_OUT_RE = re.compile(r'^\s*(?:(?P<label>.+?)\s*)?~>\s*(?P<target>.+?)\s*$')
MSGFLOW_IN_RE = re.compile(r'^\s*(?:(?P<label>.+?)\s*)?<~\s*(?P<target>.+?)\s*$')
FRONTMATTER_RE = re.compile(r'^(?P<key>[A-Za-zÄÖÜäöüß ]+):\s*(?P<value>.*)$')

UNASSIGNED_LANE = 'Nicht zugeordnet'
EXTERN_KEYS = {'extern', 'externer beteiligter', 'externe beteiligte', 'external'}


def resolve_type(typewords_raw, raw_line):
    """Ordnet die Typwörter vor dem Doppelpunkt einem internen Elementtyp zu.

    Gibt (typ, event_kind, event_direction) zurück; event_kind/-direction
    sind nur für Start-/Zwischen-/Endereignisse mit Typisierung gesetzt.
    """
    norm = re.sub(r'\s+', ' ', typewords_raw.strip().lower())
    if norm in SIMPLE_TYPE_ALIASES:
        return SIMPLE_TYPE_ALIASES[norm], None, None

    words = norm.split(' ')
    usage = EVENT_USAGE_WORDS.get(words[0])
    if usage is None:
        raise ValueError(f'Unbekannter Schritt-Typ: {typewords_raw!r} (Zeile: {raw_line!r})')

    kind = None
    direction = None
    for w in words[1:]:
        if w in EVENT_KIND_WORDS:
            if kind is not None:
                raise ValueError(f'Mehrfache Ereignis-Typisierung in {typewords_raw!r} (Zeile: {raw_line!r})')
            kind = EVENT_KIND_WORDS[w]
        elif w in EVENT_DIRECTION_WORDS:
            if direction is not None:
                raise ValueError(f'Mehrfache Richtungsangabe in {typewords_raw!r} (Zeile: {raw_line!r})')
            direction = EVENT_DIRECTION_WORDS[w]
        else:
            raise ValueError(f'Unbekanntes Wort {w!r} in Ereignis-Typ {typewords_raw!r} (Zeile: {raw_line!r})')

    if direction is None:
        direction = 'throw' if usage == 'EndEvent' else 'catch'

    if usage == 'StartEvent' and direction == 'throw':
        raise ValueError(
            f'Startereignisse sind immer eintretend/empfangend, "sendend" ist hier nicht '
            f'zulässig (Zeile: {raw_line!r})')
    if usage == 'EndEvent' and direction == 'catch':
        raise ValueError(
            f'Endereignisse sind immer auslösend/sendend, "empfangend" ist hier nicht '
            f'zulässig (Zeile: {raw_line!r})')
    if kind == 'terminate' and usage != 'EndEvent':
        raise ValueError(f'"Terminierung" ist nur als Endereignis zulässig (Zeile: {raw_line!r})')
    if kind == 'link' and usage != 'IntermediateEvent':
        raise ValueError(
            f'"Link" ist nur als Zwischenereignis zulässig, paarweise sendend/empfangend '
            f'(Zeile: {raw_line!r})')

    return usage, kind, direction


def split_lane(label):
    """Erkennt 'Verantwortlicher: Rest' am Anfang eines Labels.
    Gibt (lane_oder_None, bereinigtes_label) zurück."""
    if ':' not in label:
        return None, label
    prefix, rest = label.split(':', 1)
    prefix = prefix.strip()
    rest = rest.strip()
    if not rest or not prefix:
        return None, label
    if len(prefix) > 30 or len(prefix.split()) > 4:
        return None, label
    if '?' in prefix or not prefix[0].isalpha():
        return None, label
    return prefix, rest


class Step:
    def __init__(self, sid, typ, label, order, event_kind=None, event_direction=None):
        self.id = sid
        self.type = typ
        self.order = order
        self.edges = []  # (label_or_None, target_id)
        self.msg_flows = []  # (direction 'out'/'in', label_or_None, externer_name)
        self.event_kind = event_kind
        self.event_direction = event_direction
        if typ in UNCONNECTED_TYPES:
            self.lane = None
            self.label = label.strip()
        else:
            lane, clean = split_lane(label.strip())
            self.lane = lane
            self.label = clean


def parse_markdown(text):
    meta = {}
    steps = {}
    order = []
    externals = []
    current = None

    for raw_line in text.splitlines():
        stripped = raw_line.strip()
        if not stripped or stripped.startswith('#'):
            continue

        step_m = STEP_RE.match(stripped)
        if not step_m and current is not None:
            if '~>' in stripped:
                m = MSGFLOW_OUT_RE.match(stripped)
                if m:
                    current.msg_flows.append(('out', m.group('label'), m.group('target').strip()))
                    continue
            if '<~' in stripped:
                m = MSGFLOW_IN_RE.match(stripped)
                if m:
                    current.msg_flows.append(('in', m.group('label'), m.group('target').strip()))
                    continue
            if '->' in stripped:
                m = ARROW_RE.match(stripped)
                if m:
                    current.edges.append((m.group('label'), m.group('target')))
                    continue

        if step_m:
            sid = step_m.group('id')
            typ, event_kind, event_direction = resolve_type(step_m.group('typewords'), raw_line)
            label = step_m.group('label')
            if sid in steps:
                raise ValueError(f'Doppelte Schritt-ID: {sid!r}')
            st = Step(sid, typ, label, len(order), event_kind, event_direction)
            steps[sid] = st
            order.append(sid)
            current = st
            continue

        fm = FRONTMATTER_RE.match(stripped)
        if fm and current is None:
            key = fm.group('key').strip().lower()
            value = fm.group('value').strip()
            if key in EXTERN_KEYS:
                externals.append(value)
            else:
                meta[key] = value
            continue

        if current is None:
            continue
        raise ValueError(f'Zeile konnte nicht interpretiert werden: {raw_line!r}')

    flow_order = [sid for sid in order if steps[sid].type not in UNCONNECTED_TYPES]
    for i, sid in enumerate(flow_order):
        st = steps[sid]
        if not st.edges and st.type != 'EndEvent':
            if i + 1 < len(flow_order):
                st.edges.append((None, flow_order[i + 1]))

    for st in steps.values():
        for _, tgt in st.edges:
            if tgt not in steps:
                raise ValueError(f'Schritt {st.id!r} verweist auf unbekanntes Ziel {tgt!r}')
            if st.type in UNCONNECTED_TYPES or steps[tgt].type in UNCONNECTED_TYPES:
                raise ValueError(
                    f'Sequenzfluss {st.id!r} -> {tgt!r} nicht erlaubt: Hinweise, Datenobjekte, '
                    f'Datenspeicher und Gruppen sind keine Ablaufelemente (allenfalls per Notiz '
                    f'zuordnen, in PICTURE nach dem Import als Assoziation verbinden).')
        for _, _, target in st.msg_flows:
            if target not in externals:
                raise ValueError(
                    f'Schritt {st.id!r}: unbekannter externer Beteiligter {target!r} - vorher mit '
                    f'"Extern: {target}" deklarieren.')

    incoming_count = defaultdict(int)
    for st in steps.values():
        for _, tgt in st.edges:
            incoming_count[tgt] += 1
    for st in steps.values():
        if st.type == 'EventBasedGateway' and incoming_count[st.id] > 1:
            raise ValueError(
                f'Ereignisbasiertes Gateway {st.id!r} hat mehrere eingehende Kanten - es darf laut '
                f'Modellierregeln nicht als Zusammenführung genutzt werden.')

    return meta, steps, order, externals


# ---------------------------------------------------------------------------
# 2) Layer-Berechnung (gemeinsam für beide Layout-Modi)
# ---------------------------------------------------------------------------
def compute_layers(steps, order):
    WHITE, GRAY, BLACK = 0, 1, 2
    color = {sid: WHITE for sid in order}
    back_edges = set()

    def dfs(u):
        color[u] = GRAY
        for _, v in steps[u].edges:
            if color[v] == WHITE:
                dfs(v)
            elif color[v] == GRAY:
                back_edges.add((u, v))
        color[u] = BLACK

    for sid in order:
        if color[sid] == WHITE:
            dfs(sid)

    fwd_preds = {sid: [] for sid in order}
    for sid in order:
        for _, tgt in steps[sid].edges:
            if (sid, tgt) in back_edges:
                continue
            fwd_preds[tgt].append(sid)

    layer = {}

    def longest_path(sid, visiting=None):
        if sid in layer:
            return layer[sid]
        visiting = (visiting or set()) | {sid}
        preds = fwd_preds[sid]
        layer[sid] = 0 if not preds else 1 + max(longest_path(p, visiting) for p in preds)
        return layer[sid]

    for sid in order:
        longest_path(sid)

    return layer, fwd_preds, back_edges


# ---------------------------------------------------------------------------
# 2a) Layout ohne Lanes: Schichten von oben nach unten
# ---------------------------------------------------------------------------
COLUMN_WIDTH = 170
ROW_HEIGHT = 170
MARGIN = 80


def layout_vertical(steps, order):
    layer, fwd_preds, back_edges = compute_layers(steps, order)
    max_layer = max(layer.values()) if layer else 0
    layers = {i: [] for i in range(max_layer + 1)}
    for sid in order:
        layers[layer[sid]].append(sid)

    x_pos = {}
    for i in sorted(layers):
        nodes_in_layer = sorted(layers[i], key=lambda s: steps[s].order)
        if i == 0:
            for idx, sid in enumerate(nodes_in_layer):
                x_pos[sid] = idx * COLUMN_WIDTH
        else:
            bary = {}
            for sid in nodes_in_layer:
                preds = fwd_preds[sid]
                bary[sid] = (sum(x_pos[p] for p in preds) / len(preds)) if preds else steps[sid].order * COLUMN_WIDTH
            nodes_in_layer.sort(key=lambda s: (bary[s], steps[s].order))
            for idx, sid in enumerate(nodes_in_layer):
                x_pos[sid] = idx * COLUMN_WIDTH
        if nodes_in_layer:
            mean_x = sum(x_pos[s] for s in nodes_in_layer) / len(nodes_in_layer)
            for sid in nodes_in_layer:
                x_pos[sid] -= mean_x

    min_x = min(x_pos.values()) if x_pos else 0
    shift = MARGIN - min_x
    for sid in x_pos:
        x_pos[sid] += shift

    y_pos = {sid: MARGIN + layer[sid] * ROW_HEIGHT for sid in order}
    return x_pos, y_pos, back_edges, None


# ---------------------------------------------------------------------------
# 2b) Layout mit Lanes: Schichten von links nach rechts, Lanes als Zeilen
# ---------------------------------------------------------------------------
LANE_COLUMN_WIDTH = 190
LANE_HEADER_WIDTH = 30
LANE_PADDING = 40
LANE_ROW_HEIGHT = 150
LANE_MIN_HEIGHT = 150


def layout_lanes(steps, order, lanes):
    layer, fwd_preds, back_edges = compute_layers(steps, order)
    lane_index = {name: i for i, name in enumerate(lanes)}

    # je Lane: wie viele Knoten teilen sich denselben Layer? -> Zeilen je Lane
    lane_layer_nodes = defaultdict(lambda: defaultdict(list))
    for sid in order:
        st = steps[sid]
        if st.type in UNCONNECTED_TYPES:
            continue
        lane_layer_nodes[st.lane or UNASSIGNED_LANE][layer[sid]].append(sid)

    lane_rows = {}
    for lane in lanes:
        buckets = lane_layer_nodes.get(lane, {})
        lane_rows[lane] = max((len(v) for v in buckets.values()), default=1)

    lane_height = {lane: max(LANE_MIN_HEIGHT, lane_rows[lane] * LANE_ROW_HEIGHT + LANE_PADDING)
                   for lane in lanes}
    lane_top = {}
    running = 0
    for lane in lanes:
        lane_top[lane] = running
        running += lane_height[lane]
    pool_height = running

    x_pos, y_pos = {}, {}
    for lane in lanes:
        buckets = lane_layer_nodes.get(lane, {})
        for lyr, sids in buckets.items():
            sids_sorted = sorted(sids, key=lambda s: steps[s].order)
            n = len(sids_sorted)
            band_h = lane_height[lane]
            for row, sid in enumerate(sids_sorted):
                st = steps[sid]
                _, h = DEFAULT_SIZE.get(st.type, (100, 80))
                slot_h = band_h / n
                x_pos[sid] = MARGIN + LANE_HEADER_WIDTH + lyr * LANE_COLUMN_WIDTH
                y_pos[sid] = lane_top[lane] + row * slot_h + (slot_h - h) / 2

    # Unverbundene Artefakte (Hinweis, Datenobjekt, Datenspeicher, Gruppe): rechts
    # neben dem letzten Layer, gestapelt in der ersten Lane.
    max_layer = max(layer.values()) if layer else 0
    unconnected_i = 0
    for sid in order:
        st = steps[sid]
        if st.type not in UNCONNECTED_TYPES:
            continue
        x_pos[sid] = MARGIN + LANE_HEADER_WIDTH + (max_layer + 1) * LANE_COLUMN_WIDTH
        y_pos[sid] = lane_top[lanes[0]] + LANE_PADDING + unconnected_i * 90
        unconnected_i += 1

    return x_pos, y_pos, back_edges, (lane_top, lane_height, pool_height)


# ---------------------------------------------------------------------------
# 3) BPMN-2.0-XML aufbauen
# ---------------------------------------------------------------------------
BPMN_TAG = {
    'StartEvent': 'startEvent', 'EndEvent': 'endEvent',
    'IntermediateEvent': 'intermediateCatchEvent',  # bei "sendend" überschrieben, siehe bpmn_tag_for
    'Task': 'task', 'ManualTask': 'manualTask', 'UserTask': 'userTask',
    'ServiceTask': 'serviceTask', 'ScriptTask': 'scriptTask',
    'BusinessRuleTask': 'businessRuleTask', 'SendTask': 'sendTask', 'ReceiveTask': 'receiveTask',
    'SubProcess': 'subProcess', 'CallActivity': 'callActivity',
    'XorGateway': 'exclusiveGateway', 'OrGateway': 'inclusiveGateway', 'AndGateway': 'parallelGateway',
    'EventBasedGateway': 'eventBasedGateway',
}
ID_PREFIX = {
    'StartEvent': 'StartEvent', 'EndEvent': 'EndEvent', 'IntermediateEvent': 'IntermediateEvent',
    'Task': 'Task', 'ManualTask': 'ManualTask', 'UserTask': 'UserTask',
    'ServiceTask': 'ServiceTask', 'ScriptTask': 'ScriptTask',
    'BusinessRuleTask': 'BusinessRuleTask', 'SendTask': 'SendTask', 'ReceiveTask': 'ReceiveTask',
    'SubProcess': 'SubProcess', 'CallActivity': 'CallActivity',
    'XorGateway': 'Gateway', 'OrGateway': 'Gateway', 'AndGateway': 'Gateway', 'EventBasedGateway': 'Gateway',
    'TextAnnotation': 'TextAnnotation', 'DataObject': 'DataObject', 'DataStore': 'DataStore', 'Group': 'Group',
}

NS = {
    'bpmn': 'http://www.omg.org/spec/BPMN/20100524/MODEL',
    'bpmndi': 'http://www.omg.org/spec/BPMN/20100524/DI',
    'dc': 'http://www.omg.org/spec/DD/20100524/DC',
    'di': 'http://www.omg.org/spec/DD/20100524/DI',
}
for prefix, uri in NS.items():
    ET.register_namespace(prefix, uri)


def q(prefix, tag):
    return f'{{{NS[prefix]}}}{tag}'


def bpmn_tag_for(st):
    if st.type == 'IntermediateEvent':
        return 'intermediateThrowEvent' if st.event_direction == 'throw' else 'intermediateCatchEvent'
    return BPMN_TAG[st.type]


def sanitize_id(raw):
    s = re.sub(r'[^A-Za-z0-9_.\-]', '_', raw)
    if not s or not (s[0].isalpha() or s[0] == '_'):
        s = 'n_' + s
    return s


def spread_point(x, y, w, h, side, index, count, kind='rect'):
    """Verteilt mehrere Anschlusspunkte auf derselben Elementseite, statt sie alle
    im Mittelpunkt zusammenlaufen zu lassen (Modellierregel: eigener Anschlusspunkt
    je Kante). Bei count=1 identisch zum bisherigen Mittelpunkt-Anschluss.

    `kind` legt die tatsächliche Kontur fest, auf der die Punkte liegen müssen:
    'rect' (Rechteck, z. B. Task), 'circle' (Ereignis) oder 'diamond' (Gateway).
    Ein Punkt auf dem bloßen Begrenzungsrahmen würde bei Kreis/Raute außerhalb
    der sichtbaren Form landen und die Kante wirkt dann unverbunden."""
    frac = (index + 1) / (count + 1)
    cx, cy = x + w / 2, y + h / 2

    if kind == 'circle':
        r = min(w, h) / 2
        base_angle = {'E': 0.0, 'S': 90.0, 'W': 180.0, 'N': 270.0}[side]
        spread_deg = 70.0
        angle = math.radians(base_angle + (frac - 0.5) * spread_deg)
        return cx + r * math.cos(angle), cy + r * math.sin(angle)

    if kind == 'diamond':
        vertex = {'N': (cx, y), 'S': (cx, y + h), 'W': (x, cy), 'E': (x + w, cy)}[side]
        neg_target, pos_target = {
            'N': ((x, cy), (x + w, cy)), 'S': ((x, cy), (x + w, cy)),
            'W': ((cx, y), (cx, y + h)), 'E': ((cx, y), (cx, y + h)),
        }[side]
        offset = frac - 0.5
        t = min(abs(offset) * 2 * 0.6, 0.6)
        tx, ty = pos_target if offset > 0 else neg_target
        vx, vy = vertex
        return vx + (tx - vx) * t, vy + (ty - vy) * t

    if side == 'N':
        return x + w * frac, y
    if side == 'S':
        return x + w * frac, y + h
    if side == 'W':
        return x, y + h * frac
    if side == 'E':
        return x + w, y + h * frac
    raise ValueError(f'Unbekannte Seite: {side!r}')


GATEWAY_OUTWARD = {'N': (0, -1), 'S': (0, 1), 'E': (1, 0), 'W': (-1, 0)}
# Halbe Kantenlaenge der Raute (Standardgroesse 50x50) reicht, um deren Kontur
# in jedem Fall sicher zu verlassen, bevor die Kante abbiegt.
GATEWAY_STUB = 25


def _dedupe_consecutive(points):
    out = [points[0]]
    for p in points[1:]:
        if p != out[-1]:
            out.append(p)
    return out


def _orthogonal_middle(ox, oy, src_side, tx, ty, tgt_side):
    src_axis = 'v' if src_side in ('N', 'S') else 'h'
    tgt_axis = 'v' if tgt_side in ('N', 'S') else 'h'
    if src_axis == 'v' and tgt_axis == 'v':
        if abs(ox - tx) < 1e-6:
            return [(ox, oy), (tx, ty)]
        mid_y = oy + (ty - oy) / 2
        return [(ox, oy), (ox, mid_y), (tx, mid_y), (tx, ty)]
    if src_axis == 'h' and tgt_axis == 'h':
        if abs(oy - ty) < 1e-6:
            return [(ox, oy), (tx, ty)]
        mid_x = ox + (tx - ox) / 2
        return [(ox, oy), (mid_x, oy), (mid_x, ty), (tx, ty)]
    if src_axis == 'v':
        return [(ox, oy), (ox, ty), (tx, ty)]
    return [(ox, oy), (tx, oy), (tx, ty)]


def orthogonal_points(ox, oy, src_side, tx, ty, tgt_side,
                       src_is_gateway=False, tgt_is_gateway=False):
    """Baut einen rechtwinkligen Kantenverlauf zwischen zwei Anschlusspunkten, der
    am Start gerade in Richtung src_side abgeht und am Ziel gerade aus Richtung
    tgt_side ankommt - so, wie PICTURE Verbindungen an einem Gateway zeichnet.

    An einer Raute (`src_is_gateway`/`tgt_is_gateway`) liegt der Anschlusspunkt
    auf der Kontur, nicht am Rand einer Bounding-Box: ein direkter Kurs zum
    jeweils anderen Ende kann je nach dessen Lage durchs Innere der Raute
    zurücklaufen. Deshalb macht die Kante dort zuerst einen kurzen Schritt
    gerade nach aussen (Modellierregel: Kante nie durchs Innere eines
    Elements), bevor sie zum Ziel abbiegt - und zwar so, dass die Achse
    dieses Schritts (die einzige garantiert freie Koordinate) beim nächsten
    Abbiegen zunächst unverändert bleibt. Sonst würde die Kante beim
    Umbiegen zum Ziel auf demselben Weg zurück durch die Raute laufen, den
    sie gerade erst verlassen hat."""
    sx, sy = ox, oy
    if src_is_gateway:
        dx, dy = GATEWAY_OUTWARD[src_side]
        sx, sy = ox + dx * GATEWAY_STUB, oy + dy * GATEWAY_STUB
    ex, ey = tx, ty
    if tgt_is_gateway:
        dx, dy = GATEWAY_OUTWARD[tgt_side]
        ex, ey = tx + dx * GATEWAY_STUB, ty + dy * GATEWAY_STUB

    src_axis = 'v' if src_side in ('N', 'S') else 'h'
    tgt_axis = 'v' if tgt_side in ('N', 'S') else 'h'

    if not src_is_gateway and not tgt_is_gateway:
        points = _orthogonal_middle(ox, oy, src_side, tx, ty, tgt_side)
    elif src_is_gateway and not tgt_is_gateway:
        # sy/sx (die Stub-Achse) fixieren, solange die andere Koordinate zum
        # Ziel hin schwenkt - erst danach auf der Stub-Achse zum Ziel.
        if src_axis == 'v':
            points = [(ox, oy), (sx, sy), (tx, sy), (tx, ty)]
        else:
            points = [(ox, oy), (sx, sy), (sx, ty), (tx, ty)]
    elif tgt_is_gateway and not src_is_gateway:
        # Spiegelbildlich: erst auf der Stub-Achse des Ziels ankommen, erst
        # danach dorthin schwenken.
        if tgt_axis == 'v':
            points = [(ox, oy), (ox, ey), (ex, ey), (tx, ty)]
        else:
            points = [(ox, oy), (ex, oy), (ex, ey), (tx, ty)]
    else:
        # Beide Enden sind Rauten: von der Stub-Achse des Starts direkt auf
        # die Stub-Achse des Ziels schwenken, jede nur einmal verlassen.
        if src_axis == 'v':
            points = [(ox, oy), (sx, sy), (ex, sy), (ex, ey), (tx, ty)]
        else:
            points = [(ox, oy), (sx, sy), (sx, ey), (ex, ey), (tx, ty)]

    return _dedupe_consecutive(points)


GATEWAY_OUT_PREF = ['S', 'E', 'W', 'N']
GATEWAY_IN_PREF = ['N', 'W', 'E', 'S']


def assign_gateway_sides(steps, flows):
    """PICTURE-Gateways haben nur 4 feste Anschlusspunkte (N/O/S/W); jede Kante
    dort verlaeuft gerade. Weist daher jeder (nicht rueckwaertigen) Kante an
    einem Gateway einen eigenen Eckpunkt zu. Ab der fuenften Kante an
    demselben Gateway muss ein Punkt zweimal genutzt werden - das ist eine
    echte Grenze von PICTURE, keine Modellierungsfrage (siehe Einschraenkungen
    in Anleitung.md)."""
    touching = defaultdict(list)
    for flow_id, src, tgt, label, is_back in flows:
        if is_back:
            continue
        if SHAPE_KIND.get(steps[src].type) == 'diamond':
            touching[src].append((f'{flow_id}_src', False))
        if SHAPE_KIND.get(steps[tgt].type) == 'diamond':
            touching[tgt].append((f'{flow_id}_tgt', True))

    assigned = {}
    for sid, uses in touching.items():
        used_sides = set()
        overflow = []
        for use_id, is_incoming in uses:
            pref = GATEWAY_IN_PREF if is_incoming else GATEWAY_OUT_PREF
            for side in pref:
                if side not in used_sides:
                    assigned[use_id] = side
                    used_sides.add(side)
                    break
            else:
                overflow.append((use_id, is_incoming))
        for use_id, is_incoming in overflow:
            pref = GATEWAY_IN_PREF if is_incoming else GATEWAY_OUT_PREF
            assigned[use_id] = pref[0]
    return assigned


def build_bpmn(meta_md, steps, order, externals):
    process_name = (meta_md.get('prozess') or meta_md.get('prozessname')
                     or meta_md.get('name') or 'Neuer Prozess')
    ext_names = list(dict.fromkeys(externals))  # Reihenfolge erhalten, Duplikate entfernen

    lanes = []
    seen = set()
    for sid in order:
        st = steps[sid]
        if st.type in UNCONNECTED_TYPES:
            continue
        name = st.lane or None
        if name and name not in seen:
            seen.add(name)
            lanes.append(name)
    has_lanes = bool(lanes)
    if has_lanes and any((steps[sid].lane is None) for sid in order if steps[sid].type not in UNCONNECTED_TYPES):
        lanes.append(UNASSIGNED_LANE)

    has_collaboration = has_lanes or bool(ext_names)

    if has_lanes:
        x_pos, y_pos, back_edges, lane_geo = layout_lanes(steps, order, lanes)
    else:
        x_pos, y_pos, back_edges, lane_geo = layout_vertical(steps, order)

    node_ids = {}
    used = set()
    for sid in order:
        st = steps[sid]
        base = f'{ID_PREFIX.get(st.type, "Node")}_{sanitize_id(sid)}'
        candidate = base
        n = 1
        while candidate in used:
            n += 1
            candidate = f'{base}_{n}'
        used.add(candidate)
        node_ids[sid] = candidate

    definitions = ET.Element(q('bpmn', 'definitions'), {
        'id': 'Definitions_1',
        'targetNamespace': 'http://picture-tool.local/bpmn',
        'exporter': 'md_to_bpmn.py',
    })

    process_id = 'Process_1'
    collaboration = None
    ext_ids = {}
    msg_flow_records = []
    if has_collaboration:
        collaboration = ET.SubElement(definitions, q('bpmn', 'collaboration'), {'id': 'Collaboration_1'})
        participant_id = 'Participant_1'
        ET.SubElement(collaboration, q('bpmn', 'participant'), {
            'id': participant_id, 'name': process_name, 'processRef': process_id,
        })
        for i, name in enumerate(ext_names, start=1):
            eid = f'Participant_Ext_{i}'
            ext_ids[name] = eid
            ET.SubElement(collaboration, q('bpmn', 'participant'), {'id': eid, 'name': name})

        msg_n = 0
        for sid in order:
            st = steps[sid]
            for direction, label, target in st.msg_flows:
                msg_n += 1
                mfid = f'MsgFlow_{msg_n}'
                if direction == 'out':
                    src, tgt = node_ids[sid], ext_ids[target]
                else:
                    src, tgt = ext_ids[target], node_ids[sid]
                attrs = {'id': mfid, 'sourceRef': src, 'targetRef': tgt}
                if label:
                    attrs['name'] = label
                ET.SubElement(collaboration, q('bpmn', 'messageFlow'), attrs)
                msg_flow_records.append((mfid, sid, direction, target))

    process = ET.SubElement(definitions, q('bpmn', 'process'), {
        'id': process_id, 'name': process_name, 'isExecutable': 'false',
    })

    lane_ids = {}
    if has_lanes:
        lane_set = ET.SubElement(process, q('bpmn', 'laneSet'), {'id': 'LaneSet_1'})
        for i, lane_name in enumerate(lanes, start=1):
            lid = f'Lane_{i}'
            lane_ids[lane_name] = lid
            lane_el = ET.SubElement(lane_set, q('bpmn', 'lane'), {'id': lid, 'name': lane_name})
            for sid in order:
                st = steps[sid]
                if st.type in UNCONNECTED_TYPES:
                    continue
                if (st.lane or UNASSIGNED_LANE) == lane_name:
                    ET.SubElement(lane_el, q('bpmn', 'flowNodeRef')).text = node_ids[sid]

    incoming = {sid: [] for sid in order}
    outgoing = {sid: [] for sid in order}
    flows = []
    flow_n = 0
    for sid in order:
        st = steps[sid]
        for label, tgt in st.edges:
            flow_n += 1
            flow_id = f'Flow_{flow_n}'
            is_back = (sid, tgt) in back_edges
            flows.append((flow_id, sid, tgt, label, is_back))
            outgoing[sid].append(flow_id)
            incoming[tgt].append(flow_id)

    for sid in order:
        st = steps[sid]
        if st.type in UNCONNECTED_TYPES:
            continue
        tag = bpmn_tag_for(st)
        el = ET.SubElement(process, q('bpmn', tag), {'id': node_ids[sid], 'name': st.label})
        for fid in incoming[sid]:
            ET.SubElement(el, q('bpmn', 'incoming')).text = fid
        for fid in outgoing[sid]:
            ET.SubElement(el, q('bpmn', 'outgoing')).text = fid
        if st.event_kind:
            ET.SubElement(el, q('bpmn', EVENT_DEFINITION_TAG[st.event_kind]), {'id': f'{node_ids[sid]}_ed'})

    for sid in order:
        st = steps[sid]
        if st.type == 'TextAnnotation':
            el = ET.SubElement(process, q('bpmn', 'textAnnotation'), {'id': node_ids[sid]})
            ET.SubElement(el, q('bpmn', 'text')).text = st.label
        elif st.type == 'DataObject':
            obj_id = f'{node_ids[sid]}_obj'
            ET.SubElement(process, q('bpmn', 'dataObject'), {'id': obj_id})
            ET.SubElement(process, q('bpmn', 'dataObjectReference'), {
                'id': node_ids[sid], 'name': st.label, 'dataObjectRef': obj_id,
            })
        elif st.type == 'DataStore':
            ET.SubElement(process, q('bpmn', 'dataStoreReference'), {'id': node_ids[sid], 'name': st.label})
        elif st.type == 'Group':
            category_id = f'{node_ids[sid]}_Category'
            category = ET.SubElement(definitions, q('bpmn', 'category'), {'id': category_id})
            cv_id = f'{category_id}_Value'
            ET.SubElement(category, q('bpmn', 'categoryValue'), {'id': cv_id, 'value': st.label})
            ET.SubElement(process, q('bpmn', 'group'), {'id': node_ids[sid], 'categoryValueRef': cv_id})

    for flow_id, src, tgt, label, is_back in flows:
        attrs = {'id': flow_id, 'sourceRef': node_ids[src], 'targetRef': node_ids[tgt]}
        if label:
            attrs['name'] = label
        ET.SubElement(process, q('bpmn', 'sequenceFlow'), attrs)

    # --- Diagram Interchange ---
    diagram = ET.SubElement(definitions, q('bpmndi', 'BPMNDiagram'), {'id': 'Diagram_1'})
    plane_root = 'Collaboration_1' if has_collaboration else process_id
    plane = ET.SubElement(diagram, q('bpmndi', 'BPMNPlane'), {'id': 'Plane_1', 'bpmnElement': plane_root})

    def bounds_of(sid):
        st = steps[sid]
        w, h = DEFAULT_SIZE.get(st.type, (100, 80))
        return x_pos[sid], y_pos[sid], w, h

    pool_width = max((x_pos[sid] + bounds_of(sid)[2] for sid in order), default=400) + MARGIN
    if has_lanes:
        lane_top, lane_height, pool_height = lane_geo
    else:
        pool_height = max((y_pos[sid] + bounds_of(sid)[3] for sid in order), default=300) + MARGIN

    ext_pos = {}
    if has_collaboration:
        ET.SubElement(plane, q('bpmndi', 'BPMNShape'), {
            'id': 'Participant_1_di', 'bpmnElement': 'Participant_1', 'isHorizontal': 'true',
        }).append(_bounds_el(0, 0, pool_width, pool_height))
        if has_lanes:
            for lane_name in lanes:
                ET.SubElement(plane, q('bpmndi', 'BPMNShape'), {
                    'id': f'{lane_ids[lane_name]}_di', 'bpmnElement': lane_ids[lane_name], 'isHorizontal': 'true',
                }).append(_bounds_el(0, lane_top[lane_name], pool_width, lane_height[lane_name]))
        ext_top = pool_height + 60
        for i, name in enumerate(ext_names):
            eid = ext_ids[name]
            ex_y = ext_top + i * 130
            ext_pos[name] = (0, ex_y, pool_width, 100)
            ET.SubElement(plane, q('bpmndi', 'BPMNShape'), {
                'id': f'{eid}_di', 'bpmnElement': eid, 'isHorizontal': 'true',
            }).append(_bounds_el(0, ex_y, pool_width, 100))

    for sid in order:
        shape = ET.SubElement(plane, q('bpmndi', 'BPMNShape'), {
            'id': f'{node_ids[sid]}_di', 'bpmnElement': node_ids[sid],
        })
        x, y, w, h = bounds_of(sid)
        shape.append(_bounds_el(x, y, w, h))

    # Anschlusspunkte je (Element, Seite) zählen, damit mehrere Kanten an derselben
    # Seite nicht alle im selben Punkt zusammenlaufen (Modellierregel 4).
    def bounds_for(key):
        kind, ident = key
        return bounds_of(ident) if kind == 'n' else ext_pos[ident]

    edge_sides = {}
    anchor_group = defaultdict(list)
    use_index = {}

    def register_anchor(key, side, use_id):
        lst = anchor_group[(key, side)]
        use_index[use_id] = len(lst)
        lst.append(use_id)

    gateway_sides = assign_gateway_sides(steps, flows)

    for flow_id, src, tgt, label, is_back in flows:
        if has_lanes:
            src_side, tgt_side = ('E', 'W') if not is_back else ('S', 'S')
        elif not is_back:
            src_side, tgt_side = 'S', 'N'
        else:
            same_side = 'W' if x_pos[src] <= x_pos[tgt] else 'E'
            src_side, tgt_side = same_side, same_side
        if not is_back:
            # PICTURE-Gateways haben nur 4 feste Anschlusspunkte (N/O/S/W) - eigene
            # Zuteilung statt der obigen Layout-Konvention, siehe assign_gateway_sides().
            src_side = gateway_sides.get(f'{flow_id}_src', src_side)
            tgt_side = gateway_sides.get(f'{flow_id}_tgt', tgt_side)
        edge_sides[flow_id] = (src_side, tgt_side)
        register_anchor(('n', src), src_side, f'{flow_id}_src')
        register_anchor(('n', tgt), tgt_side, f'{flow_id}_tgt')

    for mfid, sid, direction, target in msg_flow_records:
        register_anchor(('n', sid), 'S', f'{mfid}_node')
        register_anchor(('x', target), 'N', f'{mfid}_ext')

    def shape_kind_for(key):
        kind, ident = key
        return SHAPE_KIND.get(steps[ident].type, 'rect') if kind == 'n' else 'rect'

    def spread_anchor(key, side, use_id):
        x, y, w, h = bounds_for(key)
        idx = use_index[use_id]
        count = len(anchor_group[(key, side)])
        return spread_point(x, y, w, h, side, idx, count, shape_kind_for(key))

    if has_lanes:
        pool_bottom = lane_geo[2]

    for flow_id, src, tgt, label, is_back in flows:
        edge = ET.SubElement(plane, q('bpmndi', 'BPMNEdge'), {
            'id': f'{flow_id}_di', 'bpmnElement': flow_id,
        })
        src_side, tgt_side = edge_sides[flow_id]
        ox, oy = spread_anchor(('n', src), src_side, f'{flow_id}_src')
        tx, ty = spread_anchor(('n', tgt), tgt_side, f'{flow_id}_tgt')
        if not is_back:
            src_is_gateway = SHAPE_KIND.get(steps[src].type) == 'diamond'
            tgt_is_gateway = SHAPE_KIND.get(steps[tgt].type) == 'diamond'
            points = orthogonal_points(ox, oy, src_side, tx, ty, tgt_side,
                                        src_is_gateway, tgt_is_gateway)
        elif has_lanes:
            channel_y = pool_bottom + 50
            points = [(ox, oy), (ox, channel_y), (tx, channel_y), (tx, ty)]
        else:
            offset = -60 if src_side == 'W' else 60
            channel_x = (min(ox, tx) if src_side == 'W' else max(ox, tx)) + offset
            points = [(ox, oy), (channel_x, oy), (channel_x, ty), (tx, ty)]

        for px, py in points:
            ET.SubElement(edge, q('di', 'waypoint'), {'x': f'{px:g}', 'y': f'{py:g}'})

        if label:
            # explizite Label-Position setzen, um Überlappungen mit Pfeilen/Nachbarlabels
            # zu reduzieren: am ersten Segment, leicht seitlich versetzt
            (p0x, p0y), (p1x, p1y) = points[0], points[1] if len(points) > 1 else points[0]
            mx, my = (p0x + p1x) / 2, (p0y + p1y) / 2
            if abs(p0y - p1y) < 1e-6:  # horizontales Segment -> Label darüber
                lx, ly = mx - 15, my - 20
            else:  # vertikales Segment -> Label seitlich
                lx, ly = mx + 8, my - 8
            bpmn_label = ET.SubElement(edge, q('bpmndi', 'BPMNLabel'))
            bpmn_label.append(_bounds_el(lx, ly, max(30, len(label) * 6), 14))

    for mfid, sid, direction, target in msg_flow_records:
        edge = ET.SubElement(plane, q('bpmndi', 'BPMNEdge'), {'id': f'{mfid}_di', 'bpmnElement': mfid})
        ox, oy = spread_anchor(('n', sid), 'S', f'{mfid}_node')
        tx, ty = spread_anchor(('x', target), 'N', f'{mfid}_ext')
        points = [(ox, oy), (tx, ty)] if direction == 'out' else [(tx, ty), (ox, oy)]
        for px, py in points:
            ET.SubElement(edge, q('di', 'waypoint'), {'x': f'{px:g}', 'y': f'{py:g}'})

    return definitions


def _bounds_el(x, y, w, h):
    el = ET.Element(q('dc', 'Bounds'), {
        'x': f'{x:g}', 'y': f'{y:g}', 'width': f'{w:g}', 'height': f'{h:g}',
    })
    return el


def prettify(elem):
    rough = ET.tostring(elem, encoding='utf-8')
    parsed = minidom.parseString(rough)
    return parsed.toprettyxml(indent='  ', encoding='UTF-8')


def main():
    # Windows-Konsolen laufen häufig mit einer Legacy-Kodierung (z. B. cp1252) statt UTF-8;
    # ohne dies würden Umlaute in Meldungen als Mojibake erscheinen oder das Programm abstürzen.
    for stream in (sys.stdout, sys.stderr):
        if hasattr(stream, 'reconfigure'):
            stream.reconfigure(encoding='utf-8', errors='replace')

    ap = argparse.ArgumentParser(description='Markdown-Prozessbeschreibung -> BPMN 2.0 XML')
    ap.add_argument('markdown_file')
    ap.add_argument('output_bpmn')
    args = ap.parse_args()

    with open(args.markdown_file, encoding='utf-8') as f:
        md_text = f.read()

    try:
        meta_md, steps, order, externals = parse_markdown(md_text)
        definitions = build_bpmn(meta_md, steps, order, externals)
    except ValueError as exc:
        print(f'Fehler beim Verarbeiten von {args.markdown_file}: {exc}', file=sys.stderr)
        sys.exit(1)

    xml_bytes = prettify(definitions)
    with open(args.output_bpmn, 'wb') as f:
        f.write(xml_bytes)

    n_edges = sum(len(s.edges) for s in steps.values())
    n_msgflows = sum(len(s.msg_flows) for s in steps.values())
    lanes_used = len({steps[sid].lane for sid in order if steps[sid].lane})
    extra = f', {lanes_used} Lane(s)' if lanes_used else ''
    if externals:
        extra += f', {n_msgflows} Nachrichtenfluss(e) zu {len(set(externals))} externen Beteiligten'
    print(f'OK: {len(order)} Schritte, {n_edges} Kanten{extra} -> {args.output_bpmn}')


if __name__ == '__main__':
    main()