wordeck-native/Sources/Features/Decks/DeckListView.swift

import ManaAuthUI
import ManaCore
import SwiftData
import SwiftUI

/// Navigations-Routen für die DeckListView. Tap auf eine Tile geht
/// direkt in Study-Mode, Tap auf den Edit-Button in den Deck-Detail-
/// View für Browse + Edit.
enum DeckRoute: Hashable {
    case study(deckId: String, deckName: String)
    case detail(deckId: String)
}

// swiftlint:disable type_body_length

/// Decks-Hauptbildschirm im Wordeck-Look: horizontale Scroll-Reihen
/// mit Fan-Stack-Karten-Tiles. Web-Vorbild:
/// `cards/apps/web/src/routes/decks/+page.svelte`.
struct DeckListView: View {
    @Environment(AuthClient.self) private var auth
    @Environment(ManaAuthGate.self) private var authGate
    @Environment(\.modelContext) private var context
    @Query(sort: \CachedDeck.updatedAt, order: .reverse) private var decks: [CachedDeck]

    @Binding var showCreate: Bool

    private var isGuest: Bool {
        if case .signedIn = auth.status { false } else { true }
    }

    @State private var store: DeckListStore?
    @State private var pendingShares: [PendingShare] = []
    @State private var path = NavigationPath()

    var body: some View {
        NavigationStack(path: $path) {
            ZStack {
                WordeckTheme.background.ignoresSafeArea()
                content
            }
            .navigationTitle("Decks")
            #if os(iOS)
                .navigationBarTitleDisplayMode(.inline)
            #endif
                .navigationDestination(for: DeckRoute.self) { route in
                    switch route {
                    case let .study(deckId, deckName):
                        StudySessionView(deckId: deckId, deckName: deckName)
                    case let .detail(deckId):
                        DeckDetailView(deckId: deckId)
                    }
                }
                .navigationDestination(for: PendingShareRoute.self) { route in
                    PendingShareConsumeView(share: route.share, onDone: {
                        PendingShareStore.remove(id: route.share.id)
                        pendingShares = PendingShareStore.readAll()
                    })
                }
                .toolbar { toolbar }
                .refreshable {
                    await store?.refresh()
                }
                .sheet(isPresented: $showCreate) {
                    NavigationStack {
                        DeckEditorView(mode: .create) { _ in
                            Task { await store?.refresh() }
                        }
                    }
                }
                .task {
                    if store == nil {
                        store = DeckListStore(auth: auth, context: context)
                    }
                    await store?.refresh()
                    pendingShares = PendingShareStore.readAll()
                }
                .onAppear {
                    pendingShares = PendingShareStore.readAll()
                }
        }
    }

    @ViewBuilder
    private var content: some View {
        if decks.isEmpty {
            emptyState
        } else {
            ScrollView {
                VStack(alignment: .leading, spacing: 24) {
                    pendingShareSection
                    inboxBanner
                    deckSection(title: "Eigene Decks", icon: "rectangle.stack", decks: ownDecks)
                    if !subscribedDecks.isEmpty {
                        deckSection(title: "Abonniert", icon: "globe", decks: subscribedDecks)
                    }
                }
                .padding(.vertical, 12)
            }
        }
    }

    private var ownDecks: [CachedDeck] {
        decks.filter { !$0.isFromMarketplace }
    }

    private var subscribedDecks: [CachedDeck] {
        decks.filter(\.isFromMarketplace)
    }

    @ViewBuilder
    private func deckSection(title: String, icon: String, decks: [CachedDeck]) -> some View {
        if !decks.isEmpty {
            VStack(alignment: .leading, spacing: 12) {
                HStack(spacing: 6) {
                    Image(systemName: icon)
                        .foregroundStyle(WordeckTheme.primary)
                    Text(title)
                        .font(.title3.weight(.semibold))
                        .foregroundStyle(WordeckTheme.foreground)
                    Text("\(decks.count)")
                        .font(.subheadline)
                        .foregroundStyle(WordeckTheme.mutedForeground)
                }
                .padding(.horizontal, 20)

                ScrollView(.horizontal, showsIndicators: false) {
                    HStack(alignment: .top, spacing: 16) {
                        ForEach(decks) { deck in
                            DeckStackTile(
                                deck: deck,
                                onTap: { path.append(DeckRoute.study(deckId: deck.id, deckName: deck.name)) },
                                onEdit: { path.append(DeckRoute.detail(deckId: deck.id)) }
                            )
                            .frame(width: 240)
                        }
                    }
                    .padding(.horizontal, 20)
                    .padding(.bottom, 12)
                    .scrollTargetLayout()
                }
                .scrollTargetBehavior(.viewAligned)
            }
        }
    }

    @ViewBuilder
    private var inboxBanner: some View {
        if let inbox = decks.first(where: { $0.isFromMarketplace && $0.dueCount > 0 }) {
            Button {
                path.append(DeckRoute.study(deckId: inbox.id, deckName: inbox.name))
            } label: {
                HStack(spacing: 12) {
                    Image(systemName: "tray.full.fill")
                        .font(.title3)
                        .foregroundStyle(WordeckTheme.primary)
                    VStack(alignment: .leading, spacing: 2) {
                        Text("Inbox")
                            .font(.subheadline.weight(.semibold))
                            .foregroundStyle(WordeckTheme.foreground)
                        Text("\(inbox.dueCount) fällige Karten aus abonnierten Decks")
                            .font(.caption)
                            .foregroundStyle(WordeckTheme.mutedForeground)
                    }
                    Spacer()
                    Image(systemName: "chevron.right")
                        .font(.footnote)
                        .foregroundStyle(WordeckTheme.mutedForeground)
                }
                .padding(14)
                .background(
                    WordeckTheme.primary.opacity(0.08),
                    in: RoundedRectangle(cornerRadius: 12, style: .continuous)
                )
                .overlay(
                    RoundedRectangle(cornerRadius: 12, style: .continuous)
                        .stroke(WordeckTheme.primary.opacity(0.18), lineWidth: 1)
                )
                .padding(.horizontal, 20)
            }
            .buttonStyle(.plain)
        }
    }

    @ViewBuilder
    private var pendingShareSection: some View {
        if !pendingShares.isEmpty {
            VStack(alignment: .leading, spacing: 8) {
                ForEach(pendingShares) { share in
                    NavigationLink(value: PendingShareRoute(share: share)) {
                        HStack(spacing: 12) {
                            Image(systemName: "square.and.arrow.down")
                                .foregroundStyle(WordeckTheme.warning)
                            VStack(alignment: .leading, spacing: 2) {
                                Text("Aus Teilen-Menü")
                                    .font(.subheadline.weight(.semibold))
                                    .foregroundStyle(WordeckTheme.foreground)
                                Text(share.text)
                                    .font(.caption)
                                    .foregroundStyle(WordeckTheme.mutedForeground)
                                    .lineLimit(2)
                            }
                            Spacer()
                            Image(systemName: "chevron.right")
                                .font(.footnote)
                                .foregroundStyle(WordeckTheme.mutedForeground)
                        }
                        .padding(14)
                        .background(
                            WordeckTheme.warning.opacity(0.12),
                            in: RoundedRectangle(cornerRadius: 12, style: .continuous)
                        )
                    }
                    .buttonStyle(.plain)
                }
            }
            .padding(.horizontal, 20)
        }
    }

    private var emptyState: some View {
        VStack(spacing: 16) {
            if store?.state == .loading {
                ProgressView()
                    .tint(WordeckTheme.primary)
                Text("Lade Decks …")
                    .foregroundStyle(WordeckTheme.mutedForeground)
            } else if let message = store?.errorMessage {
                ContentUnavailableView {
                    Label("Decks konnten nicht geladen werden", systemImage: "wifi.exclamationmark")
                        .foregroundStyle(WordeckTheme.foreground)
                } description: {
                    Text(message)
                        .foregroundStyle(WordeckTheme.mutedForeground)
                }
            } else if isGuest {
                ContentUnavailableView {
                    Label("Wordeck ohne Konto", systemImage: "person.crop.circle.dashed")
                        .foregroundStyle(WordeckTheme.foreground)
                } description: {
                    Text(
                        """
                        Browse den Marketplace im Entdecken-Tab — kein Konto \
                        nötig. Für eigene Decks und Cloud-Sync logge dich ein.
                        """
                    )
                    .foregroundStyle(WordeckTheme.mutedForeground)
                } actions: {
                    Button("Anmelden / Konto erstellen") {
                        authGate.require(reason: "deck-list-empty") {}
                    }
                    .buttonStyle(.borderedProminent)
                    .tint(WordeckTheme.primary)
                }
            } else {
                ContentUnavailableView {
                    Label("Noch keine Decks", systemImage: "rectangle.stack")
                        .foregroundStyle(WordeckTheme.foreground)
                } description: {
                    Text(
                        """
                        Tippe unten auf »+«, um dein erstes Deck zu erstellen, \
                        oder browse den Marketplace im Entdecken-Tab.
                        """
                    )
                    .foregroundStyle(WordeckTheme.mutedForeground)
                }
            }
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
    }

    @ToolbarContentBuilder
    private var toolbar: some ToolbarContent {
        // Auf iOS 26 übernimmt das `.tabViewBottomAccessory` aus RootView die
        // „Neues Deck"-Pille. Doppelten „+"-Button im Liquid-Glass-Layout
        // vermeiden — bottomBar-Button nur auf iOS < 26 zeigen.
        if #unavailable(iOS 26.0) {
            ToolbarItemGroup(placement: .bottomBar) {
                Button {
                    authGate.require(reason: "deck-create-toolbar") {
                        showCreate = true
                    }
                } label: {
                    Label("Deck hinzufügen", systemImage: "plus")
                        .labelStyle(.iconOnly)
                        .foregroundStyle(WordeckTheme.primary)
                }
                .accessibilityLabel("Deck hinzufügen")
                Spacer()
            }
        }
    }
}

// swiftlint:enable type_body_length