class_name Profile
extends RefCounted
## Spielstand: Münzen, Staub, Sammlung, Stapel, Kampagne, Einstellungen.
## Man startet mit einem von vier Startdecks (je ein Element im Mittelpunkt); Booster und die
## Werkstatt bringen den Rest. Jede eigene Karte hat eine Seltenheitsstufe, die +1/+1 je Stufe
## gibt (Cards.Card.leveled); kommt eine seltenere Version, ersetzt sie die alte, die zu Staub wird.

const SAVE_VERSION := 7
const CRAFT_COST := 200       # Staub für eine neue Karte (Common)
const SAVE_PATH := "user://spielstand.json"
const BOOSTER_COST := 100
const BOOSTER_SIZE := 5
const RARITY_WEIGHTS := {"Common": 45.0, "Rare": 25.0, "Super Rare": 15.0, "Ultra Rare": 10.0, "Ultimate Rare": 5.0}
const START_COINS := 150
const REWARD_WIN := 100
const REWARD_LOSS := 50
# Schwierigkeit: Leben der Gegner, KI und Münzen.
const DIFFICULTIES := {
	"leicht": {"name": "Leicht", "life": 25, "reward": 0.75, "smart": false},
	"normal": {"name": "Normal", "life": 30, "reward": 1.0, "smart": true},
	"schwer": {"name": "Schwer", "life": 35, "reward": 1.5, "smart": true},
}
# Sammlung: eine Stufe abgeben bringt Staub, eine Stufe aufwerten kostet Staub.
const DUST_DISMANTLE := {"Common": 50, "Rare": 100, "Super Rare": 200, "Ultra Rare": 500, "Ultimate Rare": 1000}
const DUST_UPGRADE := {"Rare": 100, "Super Rare": 200, "Ultra Rare": 500, "Ultimate Rare": 1000}

var coins := 0
var dust := 0
var collection := {}      # eigene Karten: id -> Seltenheitsstufe (Index in Cards.RARITIES)
var deck: Array = []      # Karten-IDs des eigenen Stapels (Game.DECK_MIN bis DECK_MAX)
var campaign_stage := 0   # Anzahl abgeschlossener Kampagnenstufen
var settings := {"volume": 0.0, "music": 0.0, "ai_speed": 1.0, "animations": true, "language": "de", "difficulty": "normal", "big_font": false}
var notices: Array[String] = []  # Meldungen für die Oberfläche (Kampagnenfortschritt)
var perk := ""            # gewähltes eigenes Merkmal (nach Kapitel 1)


## Neues Profil: noch ohne Karten, das Startdeck wählt der Spieler (choose_start).
static func starter() -> Profile:
	var p := Profile.new()
	p.coins = START_COINS
	return p


## Hat der Spieler schon ein Startdeck gewählt?
func started() -> bool:
	return not collection.is_empty()


## Das Startdeck eines Elements wird Sammlung und Stapel.
func choose_start(element: String) -> void:
	collection = {}
	deck = DeckGen.start_deck(element)
	for id in deck:
		collection[id] = 0


## Lädt den Spielstand; bei Schaden die Sicherung; sonst ein neues Profil.
static func load_or_new(path: String = SAVE_PATH) -> Profile:
	for candidate in [path, path + ".bak"]:
		if FileAccess.file_exists(candidate):
			var json := JSON.new()
			if json.parse(FileAccess.get_file_as_string(candidate)) == OK and json.data is Dictionary:
				return from_dict(json.data)
	if FileAccess.file_exists(path):
		DirAccess.rename_absolute(ProjectSettings.globalize_path(path), ProjectSettings.globalize_path(path) + ".corrupt")
	var p := starter()
	p.save(path)
	return p


## Liest jede Spielstand-Version; ältere Stände behalten Münzen, Staub, Kampagne und
## Einstellungen und bekommen die Startsammlung.
static func from_dict(d: Dictionary) -> Profile:
	var p := Profile.new()
	p.coins = int(d.get("coins", 0))
	p.dust = int(d.get("dust", 0))
	p.campaign_stage = int(d.get("campaign_stage", 0))
	if int(d.get("version", 1)) >= SAVE_VERSION:
		var coll = d.get("collection", {})
		for cid in coll:
			if Cards.has_id(cid):
				p.collection[cid] = clampi(int(coll[cid]), 0, Cards.RARITIES.size() - 1)
		var ids := []
		for cid in d.get("deck", []):
			if p.collection.has(cid) and not (cid in ids):
				ids.append(cid)
		p.deck = ids.slice(0, Game.DECK_MAX)
	var se = d.get("settings", {})
	p.settings = {"volume": float(se.get("volume", 0.0)), "music": float(se.get("music", 0.0)),
		"ai_speed": float(se.get("ai_speed", 1.0)), "animations": bool(se.get("animations", true)),
		"language": str(se.get("language", "de")), "difficulty": str(se.get("difficulty", "normal")),
		"big_font": bool(se.get("big_font", false))}
	if not DIFFICULTIES.has(p.settings.difficulty):
		p.settings.difficulty = "normal"
	p.perk = str(d.get("perk", ""))
	if not Game.PERKS.has(p.perk):
		p.perk = ""
	return p


func to_dict() -> Dictionary:
	return {"version": SAVE_VERSION, "coins": coins, "dust": dust, "collection": collection, "deck": deck,
		"campaign_stage": campaign_stage, "settings": settings, "perk": perk}


## Speichert und sichert den vorherigen Stand als .bak.
func save(path: String = SAVE_PATH) -> void:
	var abs := ProjectSettings.globalize_path(path)
	if FileAccess.file_exists(path):
		DirAccess.copy_absolute(abs, abs + ".bak")
	var f := FileAccess.open(path, FileAccess.WRITE)
	f.store_string(JSON.stringify(to_dict(), "\t"))
	f.close()


func take_notices() -> Array[String]:
	var out := notices.duplicate()
	notices.clear()
	return out


# --- Sammlung und Stapel -----------------------------------------------------------

func owns(cid: String) -> bool:
	return collection.has(cid)


func level(cid: String) -> int:
	return int(collection.get(cid, 0))


func rarity(cid: String) -> String:
	return Cards.RARITIES[level(cid)]


## Karten-ID -> Stufe für den Kampf (nur aufgewertete Karten, siehe Game.Player.looks).
func looks() -> Dictionary:
	var out := {}
	for cid in collection:
		if int(collection[cid]) > 0:
			out[cid] = int(collection[cid])
	return out


## Der Stapel für den Kampf: der gewählte, mit weiteren eigenen Karten bis DECK_MIN aufgefüllt,
## falls er zu klein ist (Karten können durch Zerlegen wegfallen).
func deck_cards() -> Array:
	return DeckGen.fill(deck.filter(func(id): return collection.has(id)), collection.keys(), Game.DECK_MIN, collection)


## Karte in den Stapel oder heraus. Gibt "" zurück oder eine Fehlermeldung.
func toggle_deck(cid: String) -> String:
	if cid in deck:
		deck.erase(cid)
		return ""
	if not owns(cid):
		return "Karte nicht in der Sammlung"
	if deck.size() >= Game.DECK_MAX:
		return "Der Stapel ist voll (%d Karten)" % Game.DECK_MAX
	deck.append(cid)
	return ""


## Wertet eine Karte um eine Stufe auf. Gibt "" zurück oder eine Fehlermeldung.
func upgrade(cid: String) -> String:
	if not owns(cid):
		return "Karte nicht in der Sammlung"
	var lvl := level(cid)
	if lvl >= Cards.RARITIES.size() - 1:
		return "Schon auf der höchsten Stufe"
	var cost: int = DUST_UPGRADE[Cards.RARITIES[lvl + 1]]
	if dust < cost:
		return "Nicht genug Staub (%d nötig)" % cost
	dust -= cost
	collection[cid] = lvl + 1
	return ""


## Entzaubern: eine Stufe abgeben bringt Staub; eine Common-Karte verlässt die Sammlung.
## Gibt "" zurück oder eine Fehlermeldung.
func dismantle(cid: String) -> String:
	if not owns(cid):
		return "Karte nicht in der Sammlung"
	var lvl := level(cid)
	dust += DUST_DISMANTLE[Cards.RARITIES[lvl]]
	if lvl == 0:
		collection.erase(cid)
		deck.erase(cid)
	else:
		collection[cid] = lvl - 1
	return ""


## Herstellen: eine fehlende Karte für Staub als Common. Gibt "" zurück oder eine Fehlermeldung.
func craft(cid: String) -> String:
	if owns(cid):
		return "Karte schon in der Sammlung"
	if dust < CRAFT_COST:
		return "Nicht genug Staub (%d nötig)" % CRAFT_COST
	dust -= CRAFT_COST
	collection[cid] = 0
	return ""


# --- Booster ----------------------------------------------------------------------

## Fünf Karten mit gewürfelter Seltenheit.
static func roll_booster(r: RandomNumberGenerator) -> Array:
	var rarities := RARITY_WEIGHTS.keys()
	var weights := PackedFloat32Array(RARITY_WEIGHTS.values())
	var pool := Cards.all()
	var out := []
	for i in BOOSTER_SIZE:
		var rar: String = rarities[r.rand_weighted(weights)]
		if i == BOOSTER_SIZE - 1 and out.all(func(x): return x.rarity == "Common"):
			rar = "Rare"  # mindestens eine Rare pro Booster
		out.append({"card": pool[r.randi_range(0, pool.size() - 1)], "rarity": rar})
	return out


## Öffnet einen Booster. Neue Karten kommen in Sammlung und Stapel (solange Platz ist). Von jeder
## Karte zählt die seltenste Version: eine höhere ersetzt die alte, die zu Staub wird; eine gleiche
## oder niedrigere wird selbst zu Staub. Gibt die Ergebnisse zurück, leer wenn die Münzen nicht reichen.
func open_booster(r: RandomNumberGenerator = null) -> Array:
	if coins < BOOSTER_COST:
		return []
	if r == null:
		r = Game.make_rng()
	coins -= BOOSTER_COST
	var out := roll_booster(r)
	for res in out:
		var lvl: int = Cards.RARITIES.find(res.rarity)
		res["new"] = not owns(res.card.id)
		res["upgraded"] = false
		res["dust"] = 0
		if res.new:
			collection[res.card.id] = lvl
			if deck.size() < Game.DECK_MAX:
				deck.append(res.card.id)
		elif lvl > level(res.card.id):
			res["upgraded"] = true
			res["dust"] = DUST_DISMANTLE[rarity(res.card.id)]
			collection[res.card.id] = lvl
		else:
			res["dust"] = DUST_DISMANTLE[res.rarity]
		dust += res.dust
	return out


# --- Kampf und Kampagne -----------------------------------------------------------

## Verbucht ein Kampfergebnis und gibt die Münzbelohnung zurück.
## stage >= 0: Kampagnenstufe; ein erster Sieg schaltet die nächste Stufe frei.
func record_battle(won: bool, stage: int = -1, reward_factor: float = 1.0) -> int:
	var reward := REWARD_LOSS
	if won:
		reward = int(round(REWARD_WIN * reward_factor))
		if stage >= 0 and stage == campaign_stage:
			campaign_stage += 1
			reward = Campaign.stage(stage).reward
			notices.append("Kampagne: %s besiegt" % Campaign.stage(stage).name)
	coins += reward
	return reward


func difficulty() -> Dictionary:
	return DIFFICULTIES.get(settings.get("difficulty", "normal"), DIFFICULTIES.normal)


func perk_unlocked() -> bool:
	return campaign_stage >= Campaign.STAGES.size()