backup-blue / AtProtoBackup / ContentView.swift

//
//  ContentView.swift
//  AtProtoBackup
//
//  Created by Corey Alexander on 8/25/25.
//

import SwiftUI
import SwiftData

struct ContentView: View {
  @Environment(\.modelContext) private var modelContext
  @Query private var items: [Account]
  @State private var showingAlert = false
  @State private var inputText = ""
  @State private var isLoading = false
  @State private var errorMessage: String?
  @State private var selectedAccount: PersistentIdentifier?
  
  var body: some View {
    NavigationSplitView {
      List(selection: $selectedAccount) {
        ForEach(items) { item in
          AccountListItemView(account: item)
            .tag(item.id)
        }
        .onDelete(perform: deleteItems)
      }
#if os(macOS)
      .navigationSplitViewColumnWidth(min: 180, ideal: 200)
#endif
      .toolbar {
#if os(iOS)
        ToolbarItem(placement: .navigationBarTrailing) {
          EditButton()
        }
#endif
        ToolbarItem {
          Button(action: addItem) {
            Label("Add Account", systemImage: "plus")
          }
        }
      }
    } detail: {
      if let selectedId = selectedAccount,
         let account = items.first(where: { $0.id == selectedId }) {
        AccountDetailView(account: account)
      } else {
        Text("Select an item")
      }
    }
    .onAppear {
      discoverAndAddBackedUpAccounts()
    }
    .alert("Add AT Protocol Account", isPresented: $showingAlert) {
      TextField("Enter handle (e.g., user.bsky.social)", text: $inputText)
      Button("Add") {
        print("[ContentView] Add button in alert pressed")
        Task {
          await lookupAndAddAccount()
        }
      }
      Button("Cancel", role: .cancel) {
        inputText = ""
        errorMessage = nil
      }
    } message: {
      if let errorMessage = errorMessage {
        Text(errorMessage)
      } else if isLoading {
        Text("Looking up DID...")
      } else {
        Text("Enter your AT Protocol handle")
      }
    }
  }
  
  
  private func addItem() {
    print("[ContentView] Add button clicked")
    inputText = ""
    errorMessage = nil
    showingAlert = true
  }
  
  private func lookupAndAddAccount() async {
    print("[ContentView] lookupAndAddAccount called with handle: '\(inputText)'")
    isLoading = true
    errorMessage = nil
    
    do {
      print("[ContentView] Starting API lookup...")
      let (parsed, jsonData) = try await ATProtocolService.shared.lookupDID(for: inputText.lowercased())
      print("[ContentView] API lookup successful - DID: \(parsed.did)")
      
      await MainActor.run {
        print("[ContentView] Creating and inserting Account object")
        withAnimation {
          let account = Account(did: parsed.did, handle: inputText, pds: parsed.pds, jsonResponse: jsonData)
          modelContext.insert(account)
          print("[ContentView] Account inserted into modelContext")

          // Auto-select the newly added account
          selectedAccount = account.id
          print("[ContentView] Auto-selected new account: \(account.id)")
        }
        showingAlert = false
        inputText = ""
        isLoading = false
        print("[ContentView] Alert dismissed, operation complete")
      }
    } catch {
      print("[ContentView] Error during lookup: \(error)")
      await MainActor.run {
        errorMessage = "Error: \(error.localizedDescription)"
        isLoading = false
      }
    }
  }
  
  private func deleteItems(offsets: IndexSet) {
    withAnimation {
      for index in offsets {
        modelContext.delete(items[index])
      }
    }
  }

  private func discoverAndAddBackedUpAccounts() {
    Task {
      do {
        let discovered = try BackupDiscovery.discoverBackedUpAccounts()
        print("[ContentView] Discovered \(discovered.count) backed up accounts")

        await MainActor.run {
          for discoveredAccount in discovered {
            // Check if account already exists
            let exists = items.contains { $0.did == discoveredAccount.did }

            if !exists {
              print("[ContentView] Adding discovered account: \(discoveredAccount.handle ?? discoveredAccount.did)")

              // Create account with discovered information from backup metadata
              let account = Account(
                did: discoveredAccount.did,
                handle: discoveredAccount.handle ?? discoveredAccount.did,
                pds: discoveredAccount.pds ?? "https://bsky.network",
                jsonResponse: nil
              )

              modelContext.insert(account)
            }
          }
        }
      } catch {
        print("[ContentView] Error discovering backed up accounts: \(error)")
      }
    }
  }
}

#Preview {
  ContentView()
    .modelContainer(for: Account.self, inMemory: false)
}