class_name Cards
## Elemente, Kombonamen, Schlüsselwörter und der Kartenpool.

const ELEMENTS: Array[String] = ["Feuer", "Wasser", "Erde", "Luft"]
const ELEMENT_COLORS := {
    "Feuer": Color("be3c23"),
    "Wasser": Color("2d64be"),
    "Erde": Color("73552d"),
    "Luft": Color("78aac8"),
}
# Jede Karte hat genau ein Element. Kombos sind die Namen verschmolzener Wesen.
const COMBOS := {
    "Feuer+Feuer": "Inferno",
    "Wasser+Wasser": "Tiefsee",
    "Erde+Erde": "Berg",
    "Luft+Luft": "Orkan",
    "Feuer+Wasser": "Dampf",
    "Feuer+Erde": "Lava",
    "Feuer+Luft": "Blitz",
    "Wasser+Erde": "Schlamm",
    "Wasser+Luft": "Sturm",
    "Erde+Luft": "Sand",
}
# Elementkreis: Wasser löscht Feuer, Feuer verbrennt Luft, Luft trägt Erde ab, Erde saugt Wasser auf.
const BEATS := {"Wasser": "Feuer", "Feuer": "Luft", "Luft": "Erde", "Erde": "Wasser"}
# Seltenheit ist reine Optik: jede Karte gibt es in jeder Stufe, die Werte bleiben gleich.
const RARITIES: Array[String] = ["gewöhnlich", "selten", "episch", "legendär", "mythisch"]
const RARITY_COLORS := {
    "gewöhnlich": Color("aaaaaa"),
    "selten": Color("4682e6"),
    "episch": Color("aa46dc"),
    "legendär": Color("f0aa28"),
    "mythisch": Color("ff5a8c"),
}
# Schlüsselwörter haben Karten nicht von Haus aus; sie werden für Mana dazugekauft (Game.upgrade).
const KEYWORDS: Array[String] = ["Schild", "Doppelschlag"]
const KEYWORD_COST := {"Schild": 3, "Doppelschlag": 4}
const KEYWORD_TEXT := {"Schild": "Blockt den ersten Schaden", "Doppelschlag": "Greift zweimal je Zug"}
const DATA_PATH := "res://data/karten.json"


static func combo_key(elements: Array) -> String:
    var sorted := elements.duplicate()
    sorted.sort_custom(func(a, b): return ELEMENTS.find(a) < ELEMENTS.find(b))
    return "+".join(sorted)


## Name der Elementkombination eines verschmolzenen Wesens; drei oder vier Elemente sind eine Chimäre.
static func combo_name(elements: Array) -> String:
    if elements.size() == 1:
        return elements[0]
    return COMBOS.get(combo_key(elements), "Chimäre")


## Elementvorteil aus Sicht von own: +1 im Vorteil, -1 im Nachteil, sonst 0.
## Hat ein Wesen mehrere Elemente, kämpft es mit dem, das gegen die Gegenseite am besten steht.
static func matchup(own: Array, other: Array) -> int:
    var mine := best_element(own, other)
    var theirs := best_element(other, own)
    if mine == "" or theirs == "":
        return 0
    return duel(mine, theirs)


## +1, wenn a b schlägt, -1, wenn b a schlägt, sonst 0.
static func duel(a: String, b: String) -> int:
    if BEATS.get(a, "") == b:
        return 1
    if BEATS.get(b, "") == a:
        return -1
    return 0


## Das Element aus own, das gegen die Elemente in other am besten steht.
static func best_element(own: Array, other: Array) -> String:
    var best := ""
    var best_score := -9
    for e in own:
        var score := 0
        for o in other:
            score += duel(e, o)
        if score > best_score:
            best = e
            best_score = score
    return best


## Welches Element ein Element schlägt (und von welchem es geschlagen wird).
static func beaten_by(element: String) -> String:
    for e in BEATS:
        if BEATS[e] == element:
            return e
    return ""


## Kosten einer Karte: Angriff plus Leben, halbiert und aufgerundet.
static func cost_of(attack: int, health: int) -> int:
    return ceili((attack + health) / 2.0)


## Name des verschmolzenen Wesens: die Kombo seiner Elemente (ein Element zählt doppelt).
static func fusion_name(elements: Array) -> String:
    return combo_name(elements if elements.size() >= 2 else [elements[0], elements[0]])


## Karte des verschmolzenen Wesens: Elemente und Schlüsselwörter beider Karten, die Werte
## bestimmt Game.fuse, eine Verschmelzung mehr als der erfahrenere Elternteil.
static func fused(a: Card, b: Card, attack: int, health: int) -> Card:
    var els := []
    for e in a.elements + b.elements:
        if not (e in els):
            els.append(e)
    els.sort_custom(func(x, y): return ELEMENTS.find(x) < ELEMENTS.find(y))
    var c := Card.new()
    c.id = "fus_%s_%s" % [a.id, b.id]
    c.name = fusion_name(els)
    c.elements = els
    c.attack = attack
    c.health = health
    c.cost = cost_of(attack, health)
    for k in KEYWORDS:
        if k in a.keywords or k in b.keywords:
            c.keywords.append(k)
    c.fusions = maxi(a.fusions, b.fusions) + 1
    return c


## Platzhalter für ein verdecktes gegnerisches Wesen: unbekanntes Element, geschätzte Werte.
static func unknown() -> Card:
    var c := Card.new()
    c.id = "?"
    c.name = "Verdeckt"
    c.name_en = "Face-down"
    c.elements = []
    c.attack = 2
    c.health = 3
    c.cost = cost_of(2, 3)
    return c


class Card extends RefCounted:
    var id: String
    var name: String      # deutscher Name (auch im Verlauf und in Tests)
    var name_en := ""     # englischer Name
    var elements: Array
    var attack: int = 0
    var health: int = 0
    var cost: int = 0     # abgeleitet: (Angriff + Leben) / 2, aufgerundet
    var keywords: Array = []  # dazugekauft, je Exemplar
    var fusions := 0      # wie oft verschmolzen (Verschmelzen kostet 1, 2, 4, 8 …)

    func to_dict() -> Dictionary:
        var d := {"id": id, "name": name, "name_en": name_en, "elements": elements, "attack": attack, "health": health}
        if not keywords.is_empty():
            d["keywords"] = keywords
        if fusions > 0:
            d["fusions"] = fusions
        return d

    static func from_dict(d: Dictionary) -> Card:
        var c := Card.new()
        c.id = d.id
        c.name = d.name
        c.name_en = str(d.get("name_en", ""))
        c.elements = Array(d.elements)
        c.attack = int(d.get("attack", 0))
        c.health = int(d.get("health", 0))
        c.cost = Cards.cost_of(c.attack, c.health)
        c.keywords = Array(d.get("keywords", []))
        c.fusions = int(d.get("fusions", 0))
        return c

    ## Eigenes Exemplar (Hand, Brett): Schlüsselwörter gehören dem Exemplar, nicht dem Pool.
    func copy() -> Card:
        return Card.from_dict(to_dict())

    ## Anzeigename in der aktuellen Sprache.
    func title() -> String:
        if name_en != "" and TranslationServer.get_locale().begins_with("en"):
            return name_en
        return name

    func is_combo() -> bool:
        return elements.size() >= 2

    func combo() -> String:
        return Cards.combo_name(elements)

    ## Mana für die nächste Verschmelzung mit dieser Karte.
    func fusion_cost() -> int:
        return 1 << fusions

    ## Kartentext: die gekauften Schlüsselwörter.
    func text() -> String:
        if keywords.is_empty():
            return ""
        var kws: Array[String] = []
        for k in Cards.KEYWORDS:
            if k in keywords:
                kws.append(tr(k))
        return ", ".join(kws) + "."


static var _all: Array = []
static var _by_id: Dictionary = {}


static func all() -> Array:
    if _all.is_empty():
        _build()
    return _all


static func by_id(id: String) -> Card:
    if _all.is_empty():
        _build()
    return _by_id[id]


static func has_id(id) -> bool:
    if _all.is_empty():
        _build()
    return _by_id.has(id)


## Lädt den Kartenpool aus data/karten.json.
static func _build() -> void:
    var json := JSON.new()
    var ok := json.parse(FileAccess.get_file_as_string(DATA_PATH))
    assert(ok == OK and json.data is Dictionary and json.data.has("karten"), "data/karten.json fehlt oder ist ungültig")
    _all = []
    _by_id = {}
    for d in json.data.karten:
        var c := Card.from_dict(d)
        assert(not _by_id.has(c.id), "Karten-ID doppelt: " + c.id)
        _by_id[c.id] = c
        _all.append(c)