package de.waypointaudio.data

import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import com.google.gson.Gson
import com.google.gson.GsonBuilder
import com.google.gson.reflect.TypeToken
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.map

// DataStore-Instanz als Extension Property (Singleton pro Context)
private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "waypoints")

/**
 * Lokaler persistenter Speicher für Wegpunkte und Touren.
 * Nutzt Jetpack DataStore mit JSON-Serialisierung via Gson.
 *
 * tourList speichert die geordnete Liste aller Tournamen (inkl. Standardtour).
 * Touren werden zusätzlich aus den Wegpunkt-tourName-Feldern abgeleitet,
 * damit auch leere Touren (ohne Wegpunkte) persistiert werden.
 *
 * tourPlaybackDefaults speichert die tour-weiten Abspiel-Vorgaben als JSON-Map.
 */
class WaypointStore(private val context: Context) {

    private val gson: Gson = GsonBuilder().create()
    private val waypointListType = object : TypeToken<List<Waypoint>>() {}.type
    private val stringListType = object : TypeToken<List<String>>() {}.type
    private val defaultsMapType = object : TypeToken<Map<String, TourPlaybackDefaults>>() {}.type

    companion object {
        private val KEY_WAYPOINTS = stringPreferencesKey("waypoints_json")
        private val KEY_TOURS = stringPreferencesKey("tours_json")
        private val KEY_TOUR_DEFAULTS = stringPreferencesKey("tour_playback_defaults_json")
        private val KEY_GPS_TRACKS = stringPreferencesKey("gps_tracks_json")
        private val KEY_TRACK_DRAFTS = stringPreferencesKey("track_drafts_json")
        // v2.4.6 — persistente Tourrouten (tourName → TourRoute, JSON).
        // Eigene Schlüssel-Datei: bestehende Backups/JSON ohne diesen Key
        // bleiben gültig (Default = leere Map).
        private val KEY_TOUR_ROUTES = stringPreferencesKey("tour_routes_json")
        // v2.5.5 — Persistente Tour-Cover (tourName → TourCover, JSON).
        // Optional pro Tour; fehlt der Eintrag, bleibt die deterministische
        // Standard-Optik (Akzentfarbe + Icon-Heuristik aus Tournamen) erhalten.
        private val KEY_TOUR_COVERS = stringPreferencesKey("tour_covers_json")
    }

    private val draftListType = object : TypeToken<List<TrackDraft>>() {}.type
    private val tourRoutesMapType = object : TypeToken<Map<String, TourRoute>>() {}.type
    private val tourCoversMapType = object : TypeToken<Map<String, TourCover>>() {}.type

    /** Liefert einen Flow mit der aktuellen Wegpunktliste. */
    val waypointsFlow: Flow<List<Waypoint>> = context.dataStore.data.map { prefs ->
        val json = prefs[KEY_WAYPOINTS] ?: "[]"
        runCatching {
            gson.fromJson<List<Waypoint>>(json, waypointListType) ?: emptyList()
        }.getOrDefault(emptyList())
    }

    /**
     * Liefert einen Flow mit der persistierten Tourliste.
     * Die Liste enthält mindestens die Standardtour.
     * Touren aus Wegpunkten werden ggf. ergänzt, aber die Reihenfolge
     * (und leere Touren) stammen aus diesem Key.
     */
    val toursFlow: Flow<List<String>> = context.dataStore.data.map { prefs ->
        val json = prefs[KEY_TOURS] ?: "[]"
        val stored = runCatching {
            gson.fromJson<List<String>>(json, stringListType) ?: emptyList()
        }.getOrDefault(emptyList())
        // Immer mindestens die Standardtour enthalten
        if (stored.isEmpty()) listOf(Waypoint.DEFAULT_TOUR_NAME) else stored
    }

    /** Liefert einen Flow mit der Map tour → TourPlaybackDefaults. */
    val tourDefaultsFlow: Flow<Map<String, TourPlaybackDefaults>> =
        context.dataStore.data.map { prefs ->
            val json = prefs[KEY_TOUR_DEFAULTS] ?: "{}"
            runCatching {
                gson.fromJson<Map<String, TourPlaybackDefaults>>(json, defaultsMapType) ?: emptyMap()
            }.getOrDefault(emptyMap())
        }

    /**
     * v2.4.6 — Persistente Tourrouten als Map (tourName → TourRoute).
     * Rückwärtskompatibel: fehlt der Key komplett, ist die Map leer.
     * Auch korrupte JSON werden defensiv auf leer abgefangen, damit eine
     * einzelne kaputte Route nicht den Rest der App blockiert.
     */
    val tourRoutesFlow: Flow<Map<String, TourRoute>> =
        context.dataStore.data.map { prefs ->
            val json = prefs[KEY_TOUR_ROUTES] ?: "{}"
            runCatching {
                gson.fromJson<Map<String, TourRoute>>(json, tourRoutesMapType) ?: emptyMap()
            }.getOrDefault(emptyMap())
        }

    /**
     * v2.5.5 — Persistente Tour-Cover als Map (tourName → TourCover).
     * Rückwärtskompatibel: fehlt der Key, ist die Map leer und Touren
     * bekommen ihre bisherige deterministische Hero-Optik.
     */
    val tourCoversFlow: Flow<Map<String, TourCover>> =
        context.dataStore.data.map { prefs ->
            val json = prefs[KEY_TOUR_COVERS] ?: "{}"
            runCatching {
                gson.fromJson<Map<String, TourCover>>(json, tourCoversMapType) ?: emptyMap()
            }.getOrDefault(emptyMap())
        }

    /** GPS-Track-Flow: Map tour → Liste von TrackPoint. */
    val gpsTracksFlow: Flow<Map<String, List<GpsTrackPoint>>> =
        context.dataStore.data.map { prefs ->
            val json = prefs[KEY_GPS_TRACKS] ?: "{}"
            runCatching {
                val mapType = object : TypeToken<Map<String, List<GpsTrackPoint>>>() {}.type
                gson.fromJson<Map<String, List<GpsTrackPoint>>>(json, mapType) ?: emptyMap()
            }.getOrDefault(emptyMap())
        }

    /**
     * Reaktiver Flow der archivierten Track-Drafts.
     * Drafts sind eigenständige, persistierte Aufzeichnungen — neue
     * Aufzeichnungen werden als zusätzliche Einträge gespeichert,
     * niemals durch Überschreiben.
     */
    val trackDraftsFlow: Flow<List<TrackDraft>> = context.dataStore.data.map { prefs ->
        val json = prefs[KEY_TRACK_DRAFTS] ?: "[]"
        runCatching {
            gson.fromJson<List<TrackDraft>>(json, draftListType) ?: emptyList()
        }.getOrDefault(emptyList())
    }

    /** Fügt einen neuen Track-Draft hinzu (immer als neuen Eintrag). */
    suspend fun addTrackDraft(draft: TrackDraft) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TRACK_DRAFTS] ?: "[]"
            val list: MutableList<TrackDraft> = runCatching {
                gson.fromJson<List<TrackDraft>>(json, draftListType)?.toMutableList()
            }.getOrNull() ?: mutableListOf()
            list.add(draft)
            prefs[KEY_TRACK_DRAFTS] = gson.toJson(list)
        }
    }

    /**
     * Aktualisiert einen vorhandenen Draft anhand seiner ID.
     * Falls noch nicht vorhanden, wird er hinzugefügt (defensiv).
     */
    suspend fun upsertTrackDraft(draft: TrackDraft) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TRACK_DRAFTS] ?: "[]"
            val list: MutableList<TrackDraft> = runCatching {
                gson.fromJson<List<TrackDraft>>(json, draftListType)?.toMutableList()
            }.getOrNull() ?: mutableListOf()
            val idx = list.indexOfFirst { it.id == draft.id }
            if (idx >= 0) list[idx] = draft else list.add(draft)
            prefs[KEY_TRACK_DRAFTS] = gson.toJson(list)
        }
    }

    /** Löscht einen Track-Draft anhand seiner ID. */
    suspend fun deleteTrackDraft(id: String) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TRACK_DRAFTS] ?: "[]"
            val list: MutableList<TrackDraft> = runCatching {
                gson.fromJson<List<TrackDraft>>(json, draftListType)?.toMutableList()
            }.getOrNull() ?: mutableListOf()
            list.removeAll { it.id == id }
            prefs[KEY_TRACK_DRAFTS] = gson.toJson(list)
        }
    }

    /**
     * Speichert die gesamte Wegpunktliste.
     *
     * v2.7.21 — Waypoint-Preservation-Guard:
     * Wenn [waypoints] leer ist, aber im DataStore bereits Wegpunkte vorhanden
     * sind, wird der Schreibvorgang NICHT ausgeführt. Das verhindert, dass eine
     * versehentlich leere oder veraltete In-Memory-Liste (`_waypoints.value`
     * aus einem Race-Condition-Fenster) bestehende Wegpunkte überschreibt.
     *
     * Explizites Leeren (Tour-Löschung, Migration) muss [saveAllForced] verwenden.
     */
    suspend fun saveAll(waypoints: List<Waypoint>) {
        context.dataStore.edit { prefs ->
            // v2.7.21 — Preservation Guard: nie eine leere Liste über eine
            // nicht-leere Liste schreiben. Schutz gegen Race-Condition-Verlust.
            if (waypoints.isEmpty()) {
                val existingJson = prefs[KEY_WAYPOINTS] ?: "[]"
                val existingList = runCatching {
                    gson.fromJson<List<Waypoint>>(existingJson, waypointListType)
                }.getOrNull()
                if (!existingList.isNullOrEmpty()) {
                    // Vorhandene Wegpunkte schützen — leere Liste wird NICHT geschrieben.
                    android.util.Log.w(
                        "WaypointStore",
                        "saveAll() mit leerer Liste blockiert: ${existingList.size} bestehende Wegpunkte bleiben erhalten."
                    )
                    return@edit
                }
            }
            prefs[KEY_WAYPOINTS] = gson.toJson(waypoints)
        }
    }

    /**
     * v2.7.21 — Forciertes Speichern ohne Preservation-Guard.
     * Nur für explizite Lösch- und Migrationsoperationen verwenden,
     * bei denen eine leere Liste das gewünschte Ergebnis ist.
     */
    suspend fun saveAllForced(waypoints: List<Waypoint>) {
        context.dataStore.edit { prefs ->
            prefs[KEY_WAYPOINTS] = gson.toJson(waypoints)
        }
    }

    /** Speichert die gesamte Tourliste (Reihenfolge bleibt erhalten). */
    suspend fun saveTours(tours: List<String>) {
        context.dataStore.edit { prefs ->
            prefs[KEY_TOURS] = gson.toJson(tours)
        }
    }

    /** Speichert oder aktualisiert die Abspiel-Vorgaben einer Tour. */
    suspend fun saveTourDefaults(tourName: String, defaults: TourPlaybackDefaults) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TOUR_DEFAULTS] ?: "{}"
            val map: MutableMap<String, TourPlaybackDefaults> = runCatching {
                gson.fromJson<Map<String, TourPlaybackDefaults>>(json, defaultsMapType)
                    ?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            map[tourName] = defaults
            prefs[KEY_TOUR_DEFAULTS] = gson.toJson(map)
        }
    }

    /** Liest die Abspiel-Vorgaben einer Tour einmalig (ohne Flow). */
    suspend fun getTourDefaults(tourName: String): TourPlaybackDefaults {
        val json = context.dataStore.data.first()[KEY_TOUR_DEFAULTS] ?: "{}"
        val map: Map<String, TourPlaybackDefaults> = runCatching {
            gson.fromJson<Map<String, TourPlaybackDefaults>>(json, defaultsMapType) ?: emptyMap()
        }.getOrDefault(emptyMap())
        return map[tourName] ?: TourPlaybackDefaults(tourName = tourName)
    }

    /** Speichert den GPS-Track einer Tour. */
    suspend fun saveGpsTrack(tourName: String, points: List<GpsTrackPoint>) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_GPS_TRACKS] ?: "{}"
            val mapType = object : TypeToken<Map<String, List<GpsTrackPoint>>>() {}.type
            val map: MutableMap<String, List<GpsTrackPoint>> = runCatching {
                gson.fromJson<Map<String, List<GpsTrackPoint>>>(json, mapType)?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            map[tourName] = points
            prefs[KEY_GPS_TRACKS] = gson.toJson(map)
        }
    }

    /**
     * v2.4.6 — Speichert (oder ersetzt) die gespeicherte Route einer Tour.
     * Setzt [TourRoute.updatedAtMillis] auf die aktuelle Zeit, sofern das
     * übergebene Objekt nicht selbst einen neueren Zeitstempel mitbringt.
     *
     * v2.7.21 — Waypoint-Preservation-Invariante:
     * Diese Funktion schreibt AUSSCHLIESSLICH in [KEY_TOUR_ROUTES].
     * [KEY_WAYPOINTS] (Audio-Wegpunkte) wird durch diesen Aufruf NIEMALS
     * verändert. Tourrouten und Audio-Wegpunkte sind vollständig getrennte
     * Speicherbereiche.
     */
    suspend fun saveTourRoute(tourName: String, route: TourRoute) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TOUR_ROUTES] ?: "{}"
            val map: MutableMap<String, TourRoute> = runCatching {
                gson.fromJson<Map<String, TourRoute>>(json, tourRoutesMapType)?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            val stamped = route.copy(
                updatedAtMillis = if (route.updatedAtMillis > 0) route.updatedAtMillis
                                  else System.currentTimeMillis()
            )
            map[tourName] = stamped
            prefs[KEY_TOUR_ROUTES] = gson.toJson(map)
        }
    }

    /** Entfernt die gespeicherte Route einer Tour (falls vorhanden). */
    suspend fun deleteTourRoute(tourName: String) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TOUR_ROUTES] ?: "{}"
            val map: MutableMap<String, TourRoute> = runCatching {
                gson.fromJson<Map<String, TourRoute>>(json, tourRoutesMapType)?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            if (map.remove(tourName) != null) {
                prefs[KEY_TOUR_ROUTES] = gson.toJson(map)
            }
        }
    }

    /**
     * Benennt die Tour einer gespeicherten Route um. Wird aus
     * [WaypointViewModel.renameTour]/[deleteTour] aufgerufen, damit die
     * Route nicht verwaist zurückbleibt.
     */
    suspend fun renameTourRouteKey(oldTour: String, newTour: String) {
        if (oldTour == newTour) return
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TOUR_ROUTES] ?: "{}"
            val map: MutableMap<String, TourRoute> = runCatching {
                gson.fromJson<Map<String, TourRoute>>(json, tourRoutesMapType)?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            val existing = map.remove(oldTour) ?: return@edit
            map[newTour] = existing.copy(updatedAtMillis = System.currentTimeMillis())
            prefs[KEY_TOUR_ROUTES] = gson.toJson(map)
        }
    }

    /** Bulk-Schreiben der Routen (für Backup-Import). Vorhandene Keys werden überschrieben. */
    suspend fun mergeTourRoutes(routes: Map<String, TourRoute>) {
        if (routes.isEmpty()) return
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TOUR_ROUTES] ?: "{}"
            val map: MutableMap<String, TourRoute> = runCatching {
                gson.fromJson<Map<String, TourRoute>>(json, tourRoutesMapType)?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            map.putAll(routes)
            prefs[KEY_TOUR_ROUTES] = gson.toJson(map)
        }
    }

    /** v2.5.5 — Speichert das Cover einer Tour (überschreibt vorhandenes). */
    suspend fun saveTourCover(tourName: String, cover: TourCover) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TOUR_COVERS] ?: "{}"
            val map: MutableMap<String, TourCover> = runCatching {
                gson.fromJson<Map<String, TourCover>>(json, tourCoversMapType)?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            map[tourName] = cover
            prefs[KEY_TOUR_COVERS] = gson.toJson(map)
        }
    }

    /** v2.5.5 — Entfernt das Cover einer Tour (falls vorhanden). */
    suspend fun deleteTourCover(tourName: String) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TOUR_COVERS] ?: "{}"
            val map: MutableMap<String, TourCover> = runCatching {
                gson.fromJson<Map<String, TourCover>>(json, tourCoversMapType)?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            if (map.remove(tourName) != null) {
                prefs[KEY_TOUR_COVERS] = gson.toJson(map)
            }
        }
    }

    /**
     * v2.5.5 — Tour-Umbenennung: Cover-Eintrag mitziehen, damit er nicht
     * unter einem verwaisten Tournamen liegen bleibt.
     */
    suspend fun renameTourCoverKey(oldTour: String, newTour: String) {
        if (oldTour == newTour) return
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TOUR_COVERS] ?: "{}"
            val map: MutableMap<String, TourCover> = runCatching {
                gson.fromJson<Map<String, TourCover>>(json, tourCoversMapType)?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            val existing = map.remove(oldTour) ?: return@edit
            map[newTour] = existing
            prefs[KEY_TOUR_COVERS] = gson.toJson(map)
        }
    }

    /** v2.5.5 — Bulk-Schreiben der Cover (für Backup-Import). */
    suspend fun mergeTourCovers(covers: Map<String, TourCover>) {
        if (covers.isEmpty()) return
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_TOUR_COVERS] ?: "{}"
            val map: MutableMap<String, TourCover> = runCatching {
                gson.fromJson<Map<String, TourCover>>(json, tourCoversMapType)?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            map.putAll(covers)
            prefs[KEY_TOUR_COVERS] = gson.toJson(map)
        }
    }

    /** Löscht den GPS-Track einer Tour. */
    suspend fun clearGpsTrack(tourName: String) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_GPS_TRACKS] ?: "{}"
            val mapType = object : TypeToken<Map<String, List<GpsTrackPoint>>>() {}.type
            val map: MutableMap<String, List<GpsTrackPoint>> = runCatching {
                gson.fromJson<Map<String, List<GpsTrackPoint>>>(json, mapType)?.toMutableMap()
            }.getOrNull() ?: mutableMapOf()
            map.remove(tourName)
            prefs[KEY_GPS_TRACKS] = gson.toJson(map)
        }
    }

    /** Fügt einen Wegpunkt hinzu oder aktualisiert einen vorhandenen (matching id). */
    suspend fun upsert(waypoint: Waypoint) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_WAYPOINTS] ?: "[]"
            val list: MutableList<Waypoint> = runCatching {
                gson.fromJson<List<Waypoint>>(json, waypointListType)?.toMutableList()
            }.getOrNull() ?: mutableListOf()

            val index = list.indexOfFirst { it.id == waypoint.id }
            if (index >= 0) list[index] = waypoint else list.add(waypoint)
            prefs[KEY_WAYPOINTS] = gson.toJson(list)
        }
    }

    /** Löscht einen Wegpunkt anhand seiner ID. */
    suspend fun delete(id: String) {
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_WAYPOINTS] ?: "[]"
            val list: MutableList<Waypoint> = runCatching {
                gson.fromJson<List<Waypoint>>(json, waypointListType)?.toMutableList()
            }.getOrNull() ?: mutableListOf()
            list.removeAll { it.id == id }
            prefs[KEY_WAYPOINTS] = gson.toJson(list)
        }
    }

    /**
     * Inkrementiert den playCount eines Wegpunkts atomar.
     * Wird vom WaypointLocationService nach erfolgreicher Wiedergabe aufgerufen.
     * @return den neuen Wegpunkt mit inkrementiertem playCount, oder null wenn nicht gefunden.
     */
    suspend fun incrementPlayCount(waypointId: String): Waypoint? {
        var updated: Waypoint? = null
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_WAYPOINTS] ?: "[]"
            val list: MutableList<Waypoint> = runCatching {
                gson.fromJson<List<Waypoint>>(json, waypointListType)?.toMutableList()
            }.getOrNull() ?: mutableListOf()

            val index = list.indexOfFirst { it.id == waypointId }
            if (index >= 0) {
                val wp = list[index].copy(playCount = list[index].playCount + 1)
                list[index] = wp
                updated = wp
            }
            prefs[KEY_WAYPOINTS] = gson.toJson(list)
        }
        return updated
    }

    /**
     * Setzt den playCount aller Wegpunkte einer Tour auf 0 zurück.
     * @return Anzahl der zurückgesetzten Wegpunkte.
     */
    suspend fun resetPlayCountsForTour(tourName: String): Int {
        var count = 0
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_WAYPOINTS] ?: "[]"
            val list: MutableList<Waypoint> = runCatching {
                gson.fromJson<List<Waypoint>>(json, waypointListType)?.toMutableList()
            }.getOrNull() ?: mutableListOf()

            for (i in list.indices) {
                val wp = list[i]
                if (wp.tourName.ifBlank { Waypoint.DEFAULT_TOUR_NAME } == tourName && wp.playCount != 0) {
                    list[i] = wp.copy(playCount = 0)
                    count++
                }
            }
            prefs[KEY_WAYPOINTS] = gson.toJson(list)
        }
        return count
    }

    /**
     * Wendet einen Abspiel-Modus auf alle Wegpunkte einer Tour an.
     * Optional: setzt auch maxPlayCount, optional: setzt playCount zurück.
     * @return Anzahl der aktualisierten Wegpunkte.
     */
    suspend fun applyPlaybackModeForTour(
        tourName: String,
        mode: PlaybackMode,
        maxPlayCount: Int?,
        resetCounts: Boolean
    ): Int {
        var count = 0
        context.dataStore.edit { prefs ->
            val json = prefs[KEY_WAYPOINTS] ?: "[]"
            val list: MutableList<Waypoint> = runCatching {
                gson.fromJson<List<Waypoint>>(json, waypointListType)?.toMutableList()
            }.getOrNull() ?: mutableListOf()

            for (i in list.indices) {
                val wp = list[i]
                if (wp.tourName.ifBlank { Waypoint.DEFAULT_TOUR_NAME } == tourName) {
                    list[i] = wp.copy(
                        playbackMode = mode,
                        maxPlayCount = if (mode == PlaybackMode.LIMITED_COUNT) maxPlayCount else null,
                        playCount = if (resetCounts) 0 else wp.playCount
                    )
                    count++
                }
            }
            prefs[KEY_WAYPOINTS] = gson.toJson(list)
        }
        return count
    }
}