class_name BattleScreen
extends Control
## Kampf: Zustand, Eingabe und Abgleich der Ansicht. Layout in BattleLayout, Animationen in BattleFx.
## Rechtsklick (oder Y) auf eine Handkarte oder ein eigenes Wesen öffnet das Kartenmenü:
## verdeckt legen, aufdecken, Eigenschaften kaufen.
## Modi: Einzelspieler, Kampagne, Netzwerk (Host, Mitspieler oder Zuschauer).

var app
var stage := -1              # Kampagnenstufe oder -1
var net_play := false        # Netzwerkspiel (auch als Zuschauer)
var online_seat := -1        # Netzwerk: eigener Platz, Zuschauer -1
var net: Net
var game: Game
var perspective: Game.Player  # der Mensch, dessen Hand unten liegt
var fx: BattleFx
var selected = null          # Game.Creature
var fusing := false          # Verschmelzen gewählt: zwei eigene Wesen anklicken
var fuse_first = null        # Game.Creature, erstes Wesen der Verschmelzung
var msg_t := 0.0
var ai_delay := 0.75
var ai_timer := 0.0
var ai_task := -1            # WorkerThreadPool-Aufgabe der laufenden KI-Berechnung
var ai_copy: Game            # Spielkopie, auf der die KI rechnet
var ai_box := {}             # Ergebnis der Berechnung (vom Thread befüllt)
var reward := -1
var ended := false
var pad: BattleGamepad
var gp_zone: String:
    get:
        return pad.zone
var gp_index: int:
    get:
        return pad.index
var skip_ai := false         # Gegnerzüge im Schnelldurchlauf
var smart_ai := true         # Vorausschau-KI (Leicht: einfache KI)
var undo_state: Game = null  # Zustand vor der letzten rückgängig machbaren Aktion
var undo_log_len := 0
var undo_t := 0.0

# Ansichten (auch für Tests)
var tiles := {}
var hand_views: Array = []
var pick_views: Array = []   # Karten der offenen Wahl
var own_views: Array = []
var enemy_views: Array = []
var hero_panels := {}        # Player -> Panel
var hero_labels := {}
var flash_until := {}        # Spielerindex -> Zeitpunkt (ms)

var hero_layer: Control
var tile_layer: Control
var hand_layer: Control
var pick_layer: Control      # Überlagerung der offenen Wahl
var pick_box: Control        # ihr Inhalt (wird je Wahl neu aufgebaut)
var pick_key := ""           # welche Wahl gerade aufgebaut ist
var deck: Deck
var log_overlay: Control
var b_log: Button
var status_panel: Panel
var fx_layer: Control
var log_box: RichTextLabel
var preview_holder: Control
var name_label: Label
var life_label: Label
var energy_label: Label
var income_label: Label
var status_label: Label
var msg_label: Label
var b_end: Button
var b_fuse: Button
var b_giveup: Button
var element_view: ElementView
var info_label: Label       # Vorschau: Elementbonus, Merkmale
var board_panel: Panel      # eigenes Brett
var menu_layer: Control     # Kartenmenü (Rechtsklick)
var menu_target = null      # Karte oder Wesen, für das das Menü offen ist
var arrivals := {}          # uid -> Rect2: Wesen, das gerade aus der Hand aufs Brett fliegt
var banner_turn := -1       # Zug, für den die Zugansage schon lief
var overlay: Control
var result_label: Label
var reward_label: Label
var notice_label: Label
var confirm: Control
var cursor_layer: Control
var wait_label: Label
var b_skip: Button
var b_undo: Button


func _init(campaign_stage: int = -1) -> void:
    stage = campaign_stage


static func online(seat: int) -> BattleScreen:
    var b := BattleScreen.new(-1)
    b.net_play = true
    b.online_seat = seat
    return b


func is_online() -> bool:
    return net_play


## Zuschauer im Netzwerk: kein eigener Platz, keine Hand.
func spectating() -> bool:
    return is_online() and online_seat < 0


func is_client() -> bool:
    return is_online() and not net.is_host


func counts_for_profile() -> bool:
    return not is_online()


func _ready() -> void:
    var s: Dictionary = app.profile.settings
    fx = BattleFx.new(self)
    fx.enabled = s.animations
    pad = BattleGamepad.new(self)
    ai_delay = 0.75 / float(s.ai_speed)
    _build_static()
    if is_online():
        net = app.net
        net.ended.connect(_on_net_ended)
        net.migrated.connect(_on_migrated)
        net.status_changed.connect(_on_net_status)
        if net.is_host:
            game = net.game
            net.action_applied.connect(after_action)
        else:
            net.snapshot_received.connect(_on_snapshot)
            wait_label.visible = true
            return  # der erste Zustand kommt vom Host
    elif stage >= 0:
        var r := Game.make_rng()
        game = Game.new_battle_with(Campaign.opponent(stage), r, false, own_rules())
    else:
        game = Game.new_battle(Game.make_rng(), own_rules())
    smart_ai = bool(app.profile.difficulty().smart) or not counts_for_profile()
    _begin()


## Kartenoptik, Gegnerleben (Schwierigkeit) und das eigene Merkmal (nach Kapitel 1).
func own_rules() -> Dictionary:
    var p: Profile = app.profile
    var rules := {"looks": p.looks()}
    if stage < 0:
        rules["opponent_life"] = int(p.difficulty().life)
    if p.perk != "" and p.perk_unlocked():
        rules["human_perks"] = [p.perk]
    return rules


func _begin() -> void:
    if is_online():
        perspective = game.players[maxi(online_seat, 0)]
    else:
        game.events.clear()
        perspective = game.current() if game.current().is_human else game.humans[0]
    build_hero_boxes()
    if is_online() and net.is_host:
        net.broadcast()
        game.events.clear()
    refresh()
    announce_turn()


func _build_static() -> void:
    var L := BattleLayout
    # oben links: Aufgeben und Verlauf, klein
    b_giveup = Style.button(self, "Aufgeben", L.B_GIVEUP, func(): confirm.visible = true)
    b_giveup.add_theme_font_size_override("font_size", 13)
    b_log = Style.button(self, "Verlauf", L.B_LOG, toggle_log)
    b_log.add_theme_font_size_override("font_size", 13)
    # Mitte: Elementzähler, Meldung, eigenes Brett mit fünf Plätzen, eigene Leiste links daneben
    Style.panel(self, L.FIELD, Style.darker(Style.PANEL, 0.9), 8)
    element_view = ElementView.new(L.FIELD)
    add_child(element_view)
    msg_label = Style.label(self, "", 15, Style.ORANGE, L.MSG, "center", true)
    board_panel = Style.panel(self, L.OWN_PANEL, Style.darker(Style.PANEL, 0.8), 10)
    var slots := Control.new()
    slots.mouse_filter = Control.MOUSE_FILTER_IGNORE
    slots.draw.connect(func():
        for j in Game.MAX_BOARD:
            Style.border(slots, L.own_slot(j), Color(1, 1, 1, 0.08), 2, 8)
            Style.border(slots, L.opp_slot(j), Color(1, 1, 1, 0.05), 2, 8))
    add_child(slots)
    status_panel = Style.panel(self, L.STATUS)
    var sx: float = L.STATUS.position.x
    var sy: float = L.STATUS.position.y
    name_label = Style.label(self, "", 18, Style.TEXT, Rect2(sx + 12, sy + 8, 190, 26), "left", true)
    name_label.clip_text = true
    life_label = Style.label(self, "", 26, Style.RED, Rect2(sx + 12, sy + 40, 190, 34), "left", true)
    energy_label = Style.label(self, "", 26, Style.BLUE, Rect2(sx + 12, sy + 78, 100, 34), "left", true)
    income_label = Style.label(self, "", 15, Style.MUTED, Rect2(sx + 100, sy + 88, 100, 22), "left")
    status_label = Style.label(self, "", 13, Style.MUTED, Rect2(sx + 12, sy + 124, 190, 22), "left")
    b_fuse = Style.button(self, "Verschmelzen", L.B_FUSE, toggle_fuse, Color("3c2858"))
    b_fuse.add_theme_font_size_override("font_size", 15)
    b_fuse.visible = false
    b_undo = Style.button(self, "Rückgängig", L.B_UNDO, undo)
    b_undo.add_theme_font_size_override("font_size", 15)
    b_undo.visible = false
    # unten: Zieh-Stapel links, Hand in der Mitte, Zug beenden rechts
    deck = Deck.new(L.DECK)
    deck.clicked.connect(func(): on_click("deck", null))
    add_child(deck)
    b_end = Style.button(self, "Zug beenden", L.B_END, end_turn, Style.PRIMARY)
    b_end.add_theme_font_size_override("font_size", 20)
    b_skip = Style.button(self, "Gegnerzüge überspringen", L.B_END, func(): skip_ai = true)
    b_skip.add_theme_font_size_override("font_size", 14)
    b_skip.visible = false
    wait_label = Style.label(self, "Warte auf den Host …", 22, Style.MUTED, Rect2(0, 300, 1280, 40), "center")
    wait_label.visible = false
    hero_layer = _layer()
    tile_layer = _layer()
    hand_layer = _layer()
    preview_holder = _layer()
    info_label = Style.label(self, "", 13, Style.TEXT, Rect2(0, 0, 220, 60), "center")
    info_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
    info_label.visible = false
    fx_layer = _layer()
    # offene Wahl: drei sehen, eine nehmen (zu Beginn fünf sehen, drei nehmen)
    pick_layer = Style.overlay(self)
    pick_box = Control.new()
    pick_box.mouse_filter = Control.MOUSE_FILTER_IGNORE
    pick_layer.add_child(pick_box)
    # Kartenmenü: durchsichtiger Fänger, der das Menü beim Klick daneben schließt
    menu_layer = Control.new()
    menu_layer.set_anchors_preset(Control.PRESET_FULL_RECT)
    menu_layer.mouse_filter = Control.MOUSE_FILTER_STOP
    menu_layer.visible = false
    menu_layer.gui_input.connect(func(ev):
        if ev is InputEventMouseButton and ev.pressed and ev.button_index == MOUSE_BUTTON_LEFT:
            close_menu())
    add_child(menu_layer)
    cursor_layer = _layer()
    # Verlauf als Überlagerung
    log_overlay = Style.overlay(self)
    log_overlay.get_child(0).gui_input.connect(func(ev):
        if ev is InputEventMouseButton and ev.pressed:
            log_overlay.visible = false)
    Style.panel(log_overlay, L.LOG_PANEL, Style.PANEL, 10, Style.MUTED, 2)
    Style.label(log_overlay, "Verlauf", 20, Style.GOLD, Rect2(L.LOG_PANEL.position + Vector2(20, 12), Vector2(300, 30)), "left", true)
    log_box = RichTextLabel.new()
    log_box.position = L.LOG_PANEL.position + Vector2(20, 50)
    log_box.size = L.LOG_PANEL.size - Vector2(40, 110)
    log_box.bbcode_enabled = true
    log_box.scroll_following = true
    log_box.add_theme_font_size_override("normal_font_size", 14)
    log_box.mouse_filter = Control.MOUSE_FILTER_IGNORE
    log_overlay.add_child(log_box)
    Style.button(log_overlay, "Schließen", Rect2(L.LOG_PANEL.end.x - 180, L.LOG_PANEL.end.y - 52, 160, 40), func(): log_overlay.visible = false)
    # Spielende
    overlay = _overlay()
    result_label = Style.label(overlay, "", 56, Style.GREEN, Rect2(0, 250, 1280, 80), "center", true)
    reward_label = Style.label(overlay, "", 26, Style.GOLD, Rect2(0, 335, 1280, 40), "center")
    notice_label = Style.label(overlay, "", 18, Style.GREEN, Rect2(0, 385, 1280, 80), "center")
    Style.button(overlay, "Zurück zum Menü", Rect2(530, 480, 220, 50), leave, Color("285a3c"))
    confirm = Style.confirm(self, "Wirklich aufgeben?", "", "Ja, aufgeben", leave, "Weiterspielen")


func toggle_log() -> void:
    log_overlay.visible = not log_overlay.visible


func _layer() -> Control:
    var c := Control.new()
    c.mouse_filter = Control.MOUSE_FILTER_IGNORE
    add_child(c)
    return c


func _overlay() -> Control:
    return Style.overlay(self)


func leave() -> void:
    if is_online():
        net.leave()
    app.show_screen(MenuScreen.new())


# --- Layout-Helfer ------------------------------------------------------------------

## Der Gegner aus Sicht der eigenen Perspektive (Zuschauer: der zweite Spieler).
func opponent() -> Game.Player:
    return game.enemy_of(perspective)


func others() -> Array:
    return [opponent()]


func slot_rect(p: Game.Player, j: int) -> Rect2:
    if p == perspective:
        return BattleLayout.own_slot(j)
    return BattleLayout.opp_slot(j)


func ref_key(ref: Dictionary) -> String:
    return "c%d" % ref.uid if ref.kind == "creature" else "p%d" % ref.index


func target_center(ref: Dictionary) -> Vector2:
    if ref.kind == "creature":
        if tiles.has(ref.uid):
            var t: CreatureView = tiles[ref.uid]
            return t.slot + t.size / 2
        return Vector2(-1, -1)
    var p: Game.Player = game.players[ref.index]
    if p == perspective:
        return BattleLayout.STATUS.get_center()
    if hero_panels.has(p):
        var panel: Panel = hero_panels[p]
        return panel.position + panel.size / 2
    return Vector2(-1, -1)


## Kasten des Gegners oben in der Mitte; ein Klick zielt auf den Helden.
func build_hero_boxes() -> void:
    Style.clear(hero_layer)
    hero_panels = {}
    hero_labels = {}
    var o := opponent()
    var box := BattleLayout.OPP_BOX
    var panel := Style.panel(hero_layer, box)
    panel.gui_input.connect(func(ev):
        if ev is InputEventMouseButton and ev.pressed and ev.button_index == MOUSE_BUTTON_LEFT:
            on_click("hero", o))
    if not o.perks.is_empty():
        panel.tooltip_text = "Merkmal: " + ", ".join(o.perks.map(func(k): return Game.PERKS[k]))
    hero_panels[o] = panel
    var labels := {}
    var title: String = ("%s · %s" % [o.name, o.title]) if o.title != "" else o.name
    if not o.perks.is_empty():
        title += " ★"
    labels["name"] = Style.label(hero_layer, title, 18, Style.TEXT, Rect2(box.position.x + 8, box.position.y + 4, box.size.x - 16, 22), "left", true)
    labels.name.clip_text = true
    labels.name.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
    labels["life"] = Style.label(hero_layer, "", 20, Style.RED, Rect2(box.position.x + 8, box.position.y + 30, 120, 24), "left", true)
    labels["stats"] = Style.label(hero_layer, "", 14, Style.MUTED, Rect2(box.position.x + 80, box.position.y + 34, box.size.x - 88, 20), "right")
    hero_labels[o] = labels


# --- Ablauf und Eingabe ------------------------------------------------------------------

func my_turn() -> bool:
    if spectating():
        return false
    return game != null and game.winner == "" and game.current() == perspective


func any_overlay() -> bool:
    return confirm.visible or overlay.visible or log_overlay.visible or menu_layer.visible


func _input(event: InputEvent) -> void:
    if game == null:
        return
    if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_RIGHT:
        var under := get_viewport().gui_get_hovered_control()
        if menu_layer.visible:
            close_menu()
        elif under is CardView and under in hand_views and my_turn():
            open_menu(under.card, Rect2(under.position, under.size))
        elif under is CreatureView and under in own_views and my_turn():
            open_menu(under.creature, Rect2(under.slot, under.size))
        else:
            cancel_all()
        get_viewport().set_input_as_handled()  # sonst schließt derselbe Klick das Menü gleich wieder
        return
    if event is InputEventJoypadButton and event.pressed:
        pad.button(event.button_index)
        return
    if not (event is InputEventKey and event.pressed and not event.echo):
        return
    match event.keycode:
        KEY_ESCAPE:
            if confirm.visible:
                confirm.visible = false
            elif menu_layer.visible:
                close_menu()
            elif log_overlay.visible:
                log_overlay.visible = false
            elif selected != null or fusing:
                cancel_all()
            elif not any_overlay():
                confirm.visible = true
        KEY_SPACE:
            if my_turn() and not any_overlay():
                end_turn()
            elif b_skip.visible:
                skip_ai = true
        KEY_U:
            if b_undo.visible:
                undo()
        KEY_ENTER, KEY_KP_ENTER:
            if overlay.visible:
                leave()
        _:
            if event.keycode >= KEY_1 and event.keycode <= KEY_9 and not spectating() and not any_overlay():
                var idx: int = event.keycode - KEY_1
                if not perspective.offer.is_empty():
                    do_pick(idx)
                elif my_turn() and idx < perspective.hand.size():
                    on_click("hand", perspective.hand[idx])
            elif event.keycode == KEY_Z and my_turn() and not any_overlay():
                on_click("deck", null)


func cancel_all() -> void:
    if confirm.visible:
        confirm.visible = false
    close_menu()
    cancel()
    refresh()


func _process(delta: float) -> void:
    if game == null:
        return
    msg_t = maxf(0.0, msg_t - delta)
    if msg_t <= 0.0 and msg_label.text != "":
        msg_label.text = ""
    if undo_t > 0.0:
        undo_t -= delta
        if undo_t <= 0.0:
            clear_undo()
    if is_online() and net.is_host:
        net.tick()
    if game.winner != "":
        if not ended:
            ended = true
            _finish()
        return
    var cur := game.current()
    if cur.is_human:
        return
    if is_client():
        return
    if skip_ai:
        ai_timer = 0.0
    else:
        ai_timer -= delta
    var action: Dictionary
    if smart_ai:
        # Die Vorausschau rechnet im Hintergrund auf einer Kopie, schon während der Wartezeit,
        # damit Animationen nicht stocken.
        if ai_task < 0:
            _start_ai(cur)
        if ai_timer > 0 or not WorkerThreadPool.is_task_completed(ai_task):
            return
        WorkerThreadPool.wait_for_task_completion(ai_task)
        ai_task = -1
        action = AI.map_action(game, ai_copy, ai_box.action)
        ai_copy = null
    else:
        if ai_timer > 0:
            return
        action = AI.choose_action_greedy(game, cur)
    AI.apply_action(game, cur, action)
    ai_timer = ai_delay * (0.6 if action.type == "end" else 1.0)
    if game.current().is_human:
        skip_ai = false
    after_action()


func _start_ai(cur: Game.Player) -> void:
    ai_copy = game.masked_clone(cur)  # verdeckte Wesen des Menschen kennt die KI nicht
    var copy := ai_copy
    var idx := game.current_idx
    var box := ai_box
    ai_task = WorkerThreadPool.add_task(func(): box["action"] = AI.choose_action(copy, copy.players[idx]))


func _exit_tree() -> void:
    if ai_task >= 0:
        WorkerThreadPool.wait_for_task_completion(ai_task)
        ai_task = -1


func _finish() -> void:
    var won := game.winner == "human"
    if counts_for_profile():
        var factor: float = float(app.profile.difficulty().reward) if stage < 0 else 1.0
        reward = app.profile.record_battle(won, stage, factor)
        app.save()
        app.sfx.play("win" if won else "lose")
    else:
        var wp := game.winner_player
        var mine: bool = wp != null and wp == perspective
        app.sfx.play("win" if mine else "lose")
    refresh()


func say(m: String) -> void:
    msg_t = 2.5
    msg_label.text = m


func cancel() -> void:
    selected = null
    fusing = false
    fuse_first = null


func play(card: Cards.Card, face_down: bool = false) -> void:
    if is_client():
        net.send_action({"type": "play", "hand": perspective.hand.find(card), "face_down": face_down})
        return
    var before: Game = game.clone() if not is_online() else null
    var log_len := game.log.size()
    var from := _hand_rect_of(card)
    var err := game.play_card(perspective, card, face_down)
    if err != "":
        say(tr(err))
        return
    if from.size.x > 0 and not perspective.board.is_empty() and perspective.board[-1].card == card:
        arrivals[perspective.board[-1].uid] = from
    # Rückgängig nur, wenn nichts weiter passiert ist (kein Wesen gestorben)
    if before != null and game.events.size() == 1 and game.events[0].type == "play":
        undo_state = before
        undo_log_len = log_len
        undo_t = 6.0
    else:
        clear_undo()


## Deckt ein eigenes verdecktes Wesen auf (kostenlos).
func do_reveal(cr: Game.Creature) -> void:
    clear_undo()
    if is_client():
        net.send_action({"type": "reveal", "uid": cr.uid})
        return
    var err := game.reveal(perspective, cr)
    if err != "":
        say(tr(err))
    after_action()


## Kauft eine Eigenschaft für eine Handkarte oder ein eigenes Wesen.
func do_upgrade(target, keyword: String) -> void:
    clear_undo()
    if is_client():
        if target is Game.Creature:
            net.send_action({"type": "upgrade", "uid": target.uid, "keyword": keyword})
        else:
            net.send_action({"type": "upgrade", "hand": perspective.hand.find(target), "keyword": keyword})
        return
    var err := game.upgrade(perspective, target, keyword)
    if err != "":
        say(tr(err))
    after_action()


## Kartenmenü neben einer Handkarte oder einem eigenen Wesen.
func open_menu(target, anchor: Rect2) -> void:
    if spectating() or not my_turn():
        return
    Style.clear(menu_layer)
    menu_target = target
    var entries := []  # [Text, Callable, aktiv]
    var is_card: bool = target is Cards.Card
    var card: Cards.Card = target if is_card else target.card
    if is_card:
        var ok := game.can_play(perspective, card)
        entries.append([tr("Verdeckt legen  ◆ %d") % card.cost, func():
            play(card, true)
            after_action(), ok[0]])
    elif target.hidden:
        entries.append([tr("Aufdecken"), func(): do_reveal(target), game.can_reveal(perspective, target)[0]])
    for kw in Cards.KEYWORDS:
        var k: String = kw
        var ok := game.can_upgrade(perspective, target, k)
        var text := "%s  ◆ %d" % [tr(k), game.upgrade_cost(perspective, k)]
        if k in card.keywords:
            text = "%s ✓" % tr(k)
        entries.append([text, func(): do_upgrade(target, k), ok[0]])
    var w := 230.0
    var h := 18.0 + entries.size() * 44 + 34
    var x := clampf(anchor.end.x + 8, 10, 1270 - w)
    if x + w > anchor.position.x and x < anchor.end.x:
        x = clampf(anchor.position.x - 8 - w, 10, 1270 - w)
    var y := clampf(anchor.position.y, 10, 790 - h)
    var box := Rect2(x, y, w, h)
    Style.panel(menu_layer, box, Style.PANEL, 10, Style.GOLD, 2)
    Style.label(menu_layer, card.title(), 15, Style.GOLD, Rect2(box.position.x + 12, box.position.y + 8, w - 24, 22), "left", true)
    var by := box.position.y + 36
    for e in entries:
        var act: Callable = e[1]
        var b := Style.button(menu_layer, e[0], Rect2(box.position.x + 12, by, w - 24, 38), func():
            close_menu()
            act.call())
        b.add_theme_font_size_override("font_size", 15)
        b.disabled = not e[2]
        by += 44
    menu_layer.visible = true


func close_menu() -> void:
    if menu_layer.visible:
        menu_layer.visible = false
        Style.clear(menu_layer)
    menu_target = null


## Verschmelzen an- und abwählen (zwei eigene Wesen, siehe Game.fuse).
func toggle_fuse() -> void:
    var on := not fusing
    cancel()
    fusing = on
    say(tr("Zwei eigene Wesen wählen") if on else tr("Abgebrochen"))
    after_action()


## Ziehen: kostet Mana, öffnet die Wahl aus drei Karten.
func do_draw() -> void:
    clear_undo()
    if is_client():
        net.send_action({"type": "draw"})
        return
    var err := game.draw(perspective)
    if err != "":
        say(tr(err))
    else:
        fx.sfx("buy")


## Nimmt eine Karte der offenen Wahl auf die Hand (jederzeit, auch außerhalb des Zugs).
func do_pick(index: int) -> void:
    if spectating() or index < 0 or index >= pick_views.size():
        return
    clear_undo()
    var from := Rect2(pick_views[index].position, pick_views[index].size)
    var card: Cards.Card = pick_views[index].card
    if is_client():
        net.send_action({"type": "pick", "index": index})
        return
    var err := game.pick(perspective, index)
    if err != "":
        say(tr(err))
        return
    fx.sfx("play")
    fx.fly_card(card, from, BattleLayout.hand_rect(perspective.hand.size(), perspective.hand.size() - 1),
        Cards.RARITIES[int(perspective.looks.get(card.id, 0))])
    after_action()


func do_fuse(a, b) -> void:
    cancel()
    clear_undo()
    if is_client():
        net.send_action({"type": "fuse", "uid": a.uid, "other": b.uid})
        return
    var err := game.fuse(perspective, a, b)
    if err != "":
        say(tr(err))


func clear_undo() -> void:
    undo_state = null
    undo_t = 0.0
    b_undo.visible = false


## Nimmt das letzte Ausspielen eines Wesens zurück (nur solange nichts Verdecktes offenbart wurde).
func undo() -> void:
    if undo_state == null:
        return
    var idx := game.players.find(perspective)
    var restored := undo_state
    restored.quiet = false
    restored.rng = game.rng
    restored.log = game.log.slice(0, undo_log_len)
    restored.say("Rückgängig.")
    game = restored
    perspective = game.players[idx]
    if is_online() and net.is_host:
        net.game = game
    clear_undo()
    cancel()
    build_hero_boxes()
    after_action()


func end_turn() -> void:
    if not my_turn():
        return
    cancel()
    clear_undo()
    if is_client():
        net.send_action({"type": "end"})
        return
    game.end_turn()
    ai_timer = ai_delay
    after_action()


func on_click(kind: String, obj) -> void:
    var g := game
    if not my_turn() or any_overlay():
        return
    if fusing:
        if kind != "own":
            cancel()
            say(tr("Abgebrochen"))
        elif fuse_first == null:
            fuse_first = obj
            say(tr("Zweites Wesen wählen"))
        elif obj == fuse_first:
            fuse_first = null
        else:
            do_fuse(fuse_first, obj)
        after_action()
        return
    if selected != null:
        var cr = selected
        selected = null
        if kind == "enemy" or kind == "hero":
            clear_undo()
            if is_client():
                net.send_action({"type": "attack", "uid": cr.uid, "target": Net.ref_dict(obj)})
            else:
                var err := g.attack(cr, obj)
                if err != "":
                    say(tr(err))
            after_action()
            return
    match kind:
        "deck":
            do_draw()
        "hand":
            var ok := g.can_play(perspective, obj)
            if not ok[0]:
                say(tr(ok[1]))
            else:
                play(obj)
        "own":
            if obj.hidden:
                do_reveal(obj)
                return
            if obj.can_attack():
                selected = obj
                say(tr("Wähle ein Angriffsziel"))
            else:
                say(tr("%s kann nicht angreifen") % obj.card.title())
    after_action()


func on_tile_click(cr: Game.Creature) -> void:
    var o = cr.owner()
    if o == null:
        return
    if o == perspective:
        on_click("own", cr)
    elif o.alive():
        on_click("enemy", cr)


## Zugansage, wenn der eigene Zug beginnt.
func announce_turn() -> void:
    if game == null or not my_turn() or banner_turn == game.turn:
        return
    banner_turn = game.turn
    fx.banner(tr("Dein Zug"), Style.GOLD)
    fx.sfx("turn")


func _hand_rect_of(card: Cards.Card) -> Rect2:
    for v in hand_views:
        if v.card == card:
            return Rect2(v.position, v.size)
    return Rect2()


## Vorschau schwebt neben der gezeigten Karte (anchor), darunter die Zusatzzeile (info).
func show_preview(card, entered: bool, owner_looks: Dictionary = {}, info: String = "", anchor: Rect2 = Rect2()) -> void:
    Style.clear(preview_holder)
    info_label.visible = entered and info != ""
    info_label.text = info if entered else ""
    if entered and card != null:
        var r := BattleLayout.preview_rect(anchor)
        var v := CardView.new(card, r.size, false, Cards.RARITIES[int(owner_looks.get(card.id, 0))])
        v.position = r.position
        v.mouse_filter = Control.MOUSE_FILTER_IGNORE
        preview_holder.add_child(v)
        var ir := BattleLayout.info_rect(r)
        info_label.position = ir.position
        info_label.size = ir.size


## Eigene Hand- und Wahlkarte: zeigt den Elementbonus, den sie offen gelegt bekäme.
func show_hand_preview(card: Cards.Card, entered: bool, anchor: Rect2 = Rect2()) -> void:
    var a := game.forecast(perspective, card)
    var info := ""
    if a > 0:
        info = tr("Elementbonus +%d/+%d") % [a, a]
    elif a < 0:
        info = tr("Elementbonus %d/%d") % [a, a]
    show_preview(card, entered, perspective.looks, info, anchor)


## Offene Wahl als Überlagerung: nur neu aufbauen, wenn sich das Angebot geändert hat.
func build_pick() -> void:
    var h := perspective
    var key := ""
    if not spectating() and not h.offer.is_empty():
        key = "%d:%s" % [h.picks_left, ",".join(h.offer.map(func(c): return c.id))]
    if key == pick_key:
        return
    pick_key = key
    Style.clear(pick_box)
    pick_views = []
    if key == "":
        pick_layer.visible = false
        return
    var box := BattleLayout.PICK_PANEL
    Style.panel(pick_box, box, Style.PANEL, 12, Style.GOLD, 2)
    Style.label(pick_box, tr("Wähle %d von %d") % [h.picks_left, h.offer.size()], 26, Style.GOLD,
        Rect2(box.position.x, box.position.y + 24, box.size.x, 40), "center", true)
    for i in h.offer.size():
        var card: Cards.Card = h.offer[i]
        var r := BattleLayout.pick_rect(h.offer.size(), i)
        var v := CardView.new(card, r.size, false, Cards.RARITIES[int(h.looks.get(card.id, 0))])
        v.position = r.position
        v.lift = true
        apply_forecast(v)
        var idx := i
        v.clicked.connect(func(_view): do_pick(idx))
        pick_box.add_child(v)
        pick_views.append(v)
    pick_layer.visible = true
    if Style.animations:
        for i in pick_views.size():
            fx.deal(pick_views[i], i)


## Hand- und Wahlkarten tragen den Elementbonus als Vorschau.
func apply_forecast(v: CardView) -> void:
    v.bonus = game.forecast(perspective, v.card)


## Was den Angriff eines Wesens gerade hebt oder senkt.
func creature_info(cr: Game.Creature) -> String:
    var parts: Array[String] = []
    if cr.aura > 0:
        parts.append(tr("Elementbonus +%d/+%d") % [cr.aura, cr.aura])
    elif cr.aura < 0:
        parts.append(tr("Elementbonus %d/%d") % [cr.aura, cr.aura])
    var perk := cr.power() - cr.attack - cr.aura
    if perk > 0:
        parts.append(tr("Merkmal +%d") % perk)
    if cr.hidden:
        parts.append(tr("verdeckt"))
    return " · ".join(parts)


## Elementvorteil des gewählten Angreifers gegen ein mögliches Ziel; gegen Verdeckte unbekannt.
func matchup_for(cr: Game.Creature) -> int:
    if selected != null and not cr.hidden and game.can_attack(selected, cr)[0]:
        return Game.matchup_bonus(selected, cr)
    return 0


class Deck extends Control:
    signal clicked
    var enabled := true
    var count := 0
    var cost := Game.DRAW_COST

    func _init(rect: Rect2) -> void:
        position = rect.position
        size = rect.size
        mouse_filter = Control.MOUSE_FILTER_STOP

    func _gui_input(event: InputEvent) -> void:
        if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
            accept_event()
            clicked.emit()

    func _draw() -> void:
        for k in range(2, -1, -1):
            var r := Rect2(Vector2(k * 3, -k * 3), size - Vector2(6, 12)).grow(0)
            r.position.y += 6
            draw_style_box(Style.box(Color("3c285a"), 8, Style.GOLD if enabled else Style.MUTED, 2), r)
            if k == 0:
                Style.border(self, r.grow(-12), Color("5a3c82"), 2, 6)
                Style.text(self, tr("Ziehen"), 16, Style.TEXT if enabled else Style.MUTED, r.get_center() + Vector2(0, -12), "center", true)
                Style.text(self, "◆ %d" % cost, 20, Style.BLUE if enabled else Style.MUTED, r.get_center() + Vector2(0, 14), "center", true)
                Style.text(self, str(count), 12, Style.MUTED, Vector2(r.get_center().x, r.end.y - 18), "center")
        if not enabled:
            draw_rect(Rect2(Vector2.ZERO, size), Color(0, 0, 0, 0.35))




# --- Netzwerk -------------------------------------------------------------------------------

func _on_snapshot(snap: Dictionary) -> void:
    var first := game == null
    game = Game.from_snapshot(snap)
    wait_label.visible = false
    if first:
        _begin()
        return
    perspective = game.players[maxi(online_seat, 0)]
    build_hero_boxes()
    after_action()


## Host-Wechsel: das Spiel läuft jetzt auf diesem Rechner weiter.
func _on_migrated() -> void:
    game = net.game
    if not net.action_applied.is_connected(after_action):
        net.action_applied.connect(after_action)
    wait_label.visible = false
    perspective = game.players[online_seat]
    build_hero_boxes()
    say("Du bist jetzt Host.")
    after_action()


func _on_net_status() -> void:
    wait_label.text = net.status
    wait_label.visible = true


func _on_net_ended(reason: String) -> void:
    if game == null or game.winner == "":
        say(reason)
        await get_tree().create_timer(1.5).timeout
        if is_inside_tree():
            app.show_screen(MenuScreen.new())


# --- Ereignisse ----------------------------------------------------------------------------

## Nach jeder Aktion: Ereignisse sichern, Ansicht angleichen, Animationen abspielen.
func after_action() -> void:
    if is_online() and net.is_host:
        net.broadcast()
    var evs := game.events.duplicate()
    game.events.clear()
    var centers := {}
    for ev in evs:
        for key in ["target", "attacker", "source"]:
            if ev.has(key):
                centers[ref_key(ev[key])] = target_center(ev[key])
    refresh()
    fx.play_events(evs, centers)
    announce_turn()


# --- Ansicht angleichen --------------------------------------------------------------------

func refresh() -> void:
    if game == null:
        return
    var g := game
    var h := perspective
    var now := Time.get_ticks_msec()
    var mine := my_turn()
    hand_views = []
    own_views = []
    enemy_views = []

    for o in others():
        var panel: Panel = hero_panels[o]
        var bcol = null
        var bw := 0
        if g.current() == o:
            bcol = Style.BLUE
            bw = 3
        if selected != null and o.alive() and g.can_attack(selected, o)[0]:
            bcol = Style.ORANGE
            bw = 3
        if int(flash_until.get(g.players.find(o), 0)) > now:
            bcol = Style.RED
            bw = 4
        panel.add_theme_stylebox_override("panel", Style.box(Style.PANEL if o.alive() else Style.darker(Style.PANEL, 0.6), 8, bcol, bw))
        panel.mouse_filter = Control.MOUSE_FILTER_STOP if o.alive() else Control.MOUSE_FILTER_IGNORE
        var labels: Dictionary = hero_labels[o]
        labels.name.add_theme_color_override("font_color", Style.TEXT if o.alive() else Style.MUTED)
        if o.alive():
            labels.life.text = "♥ %d" % maxi(o.life, 0)
            labels.stats.text = "Hand %d  ◆ %d" % [o.hand.size(), o.energy]
        else:
            labels.life.text = "besiegt"
            labels.life.add_theme_color_override("font_color", Style.MUTED)
            labels.stats.text = ""

    var seen := {}
    for p in g.players:
        for j in p.board.size():
            var cr: Game.Creature = p.board[j]
            var rect := slot_rect(p, j)
            seen[cr.uid] = true
            var tile: CreatureView
            if tiles.has(cr.uid):
                tile = tiles[cr.uid]
                tile.creature = cr
                if tile.size != rect.size:  # erst die Mindestgröße, sonst bleibt die Kachel groß
                    tile.custom_minimum_size = rect.size
                    tile.size = rect.size
                    tile.pivot_offset = rect.size / 2
                    tile.set_process(Style.rarity_animated(tile.rarity()))
            else:
                tile = CreatureView.new(cr, rect.size)
                tile.position = rect.position
                tile.slot = rect.position
                tiles[cr.uid] = tile
                tile_layer.add_child(tile)
                var looks: Dictionary = p.looks
                tile.hover.connect(func(card, entered):
                    if tile.secret:
                        show_preview(null, false)
                    else:
                        show_preview(card, entered, looks, creature_info(tile.creature) if entered else "", Rect2(tile.slot, tile.size)))
                var uid := cr.uid
                tile.clicked.connect(func(_v):
                    var c := game.find_creature(uid)
                    if c != null:
                        on_tile_click(c))
                if arrivals.has(cr.uid):
                    fx.fly_in(tile, arrivals[cr.uid])
                    arrivals.erase(cr.uid)
                else:
                    fx.pop_in(tile)
            tile.slot = rect.position
            if not tile.busy and tile.position != rect.position:
                fx.move_to(tile, rect.position)
            var b = null
            var w := 2
            if cr == selected or cr == fuse_first:
                b = Style.YELLOW
                w = 4
            elif fusing and p == h and mine:
                b = Style.PURPLE
                w = 3
            elif selected != null and g.can_attack(selected, cr)[0]:
                b = Style.ORANGE
                w = 3
            elif p == h and mine and cr.can_attack():
                b = Style.GREEN
                w = 3
            tile.border = b
            tile.width = w
            tile.secret = cr.hidden and p != h
            tile.matchup = matchup_for(cr)
            tile.queue_redraw()
            if p == h:
                own_views.append(tile)
            else:
                enemy_views.append(tile)
    for uid in tiles.keys():
        if not seen.has(uid):
            var t: CreatureView = tiles[uid]
            tiles.erase(uid)
            fx.fade_out(t)
    build_pick()
    deck.visible = not spectating()
    deck.enabled = mine and g.can_draw(h)[0]
    deck.count = g.deck.size()
    deck.cost = g.draw_cost(h)
    deck.queue_redraw()

    Style.clear(hand_layer)
    if spectating():
        Style.label(hand_layer, "Zuschauer: Hände sind verdeckt", 18, Style.MUTED, Rect2(240, BattleLayout.HAND_Y + 18, 800, 30), "center")
    else:
        for i in h.hand.size():
            var card: Cards.Card = h.hand[i]
            var playable: bool = mine and g.can_play(h, card)[0]
            var r := BattleLayout.hand_rect(h.hand.size(), i)
            var v := CardView.new(card, r.size, false, Cards.RARITIES[int(h.looks.get(card.id, 0))])
            v.position = r.position
            v.lift = mine
            apply_forecast(v)
            if playable:
                v.border = Style.GREEN
            v.dim = not playable
            v.hover.connect(func(c, e): show_hand_preview(c, e, Rect2(v.position, v.size)))
            v.clicked.connect(func(_view): on_click("hand", card))
            hand_layer.add_child(v)
            hand_views.append(v)

    var bar_border = Style.BLUE if mine else null
    if int(flash_until.get(g.players.find(h), 0)) > now:
        bar_border = Style.RED
    status_panel.add_theme_stylebox_override("panel", Style.box(Style.PANEL, 8, bar_border, 3 if bar_border != null else 0))
    name_label.text = h.name
    life_label.text = "♥ %d" % maxi(h.life, 0)
    energy_label.text = "◆ %d" % h.energy
    income_label.text = tr("nächster Zug ◆ %d") % (h.max_energy + 1)
    status_label.text = (tr("Zug %d · Du bist dran") % g.turn) if mine else (tr("Zug %d · %s ist dran …") % [g.turn, g.current().name])
    if spectating():
        status_label.text = tr("Zuschauer") + " · " + status_label.text
    b_end.disabled = not mine
    var ai_running: bool = g.winner == "" and not g.current().is_human and not is_client()
    b_skip.visible = ai_running
    b_end.visible = not ai_running and not spectating()
    b_undo.visible = undo_state != null and mine
    b_fuse.visible = mine and not spectating() and h.board.size() >= 2
    b_fuse.text = tr("Abbrechen") if fusing else tr("Verschmelzen")
    element_view.update_from(g)
    var lines: Array[String] = []
    var start := maxi(0, g.log.size() - 60)
    for i in range(start, g.log.size()):
        var line := g.log[i]
        if line.begins_with("---"):
            lines.append("[color=#6eaaf0]%s[/color]" % line)
        elif " verschmelzen zu " in line or " wird aufgedeckt." in line:
            lines.append("[color=#8c78dc]%s[/color]" % line)
        elif " bekommt " in line:
            lines.append("[color=#5ad282]%s[/color]" % line)
        else:
            lines.append(line)
    log_box.text = "\n".join(lines)
    pad.draw_cursor()

    if g.winner != "":
        var wp := g.winner_player
        if counts_for_profile():
            var won := g.winner == "human"
            result_label.text = "Sieg!" if won else "Niederlage"
            result_label.add_theme_color_override("font_color", Style.GREEN if won else Style.RED)
            reward_label.text = "+%d Münzen" % maxi(reward, 0)
            var notes: Array[String] = app.profile.take_notices()
            if not notes.is_empty():
                notice_label.text = "\n".join(notes)
        else:
            var mine_win: bool = wp != null and wp == perspective
            result_label.text = ("%s gewinnt!" % wp.name) if wp != null and wp.is_human else "Die KI gewinnt"
            result_label.add_theme_color_override("font_color", Style.GREEN if mine_win else Style.RED)
            reward_label.text = "Gemeinsame Partie, keine Münzen"
        overlay.visible = true
        confirm.visible = false