ViewController.swift

//
//  Copyright (c) 2017 Google Inc.
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//

import UIKit

import FirebaseCore
import FirebaseFirestore

class ViewController: UIViewController {

  var smokeTests: SmokeTests!

  override func viewDidLoad() {
    super.viewDidLoad()

    // [START setup]
    let settings = FirestoreSettings()

    Firestore.firestore().settings = settings
    // [END setup]
    smokeTests = SmokeTests(Firestore.firestore())
  }

  @IBAction func didTouchSmokeTestButton(_ sender: AnyObject) {
    smokeTests.runAllSmokeTests()
  }

  @IBAction func didTouchDeleteButton(_ sender: AnyObject) {
    smokeTests.deleteCollection(collection: "users")
    smokeTests.deleteCollection(collection: "cities")
  }

}

class SmokeTests: @unchecked Sendable {

  nonisolated(unsafe) private let db: Firestore

  init(_ db: Firestore) {
    self.db = db
  }

  func runAllSmokeTests() {
    // Quickstart
    Task {
      await addAdaLovelace()
      await addAlanTuring()
      await getCollection()
      listenForUsers()
    }

    // Structure Data
    demonstrateReferences()

    // Save Data
    Task {
      await setDocument()
      await dataTypes()
      setData()
      await addDocument()
      newDocument()
      await updateDocument()
      createIfMissing()
      await updateDocumentNested()
      await deleteDocument()
      deleteCollection()
      await deleteField()
      await serverTimestamp()
      serverTimestampOptions()
      await simpleTransaction()
      await transaction()
      await writeBatch()
    }

    // Retrieve Data
    Task {
      exampleData()
      exampleDataCollectionGroup()
      await getDocument()
      await customClassGetDocument()
      listenDocument()
      listenDocumentLocal()
      listenWithMetadata()
      await getMultiple()
      await getMultipleAll()
      listenMultiple()
      listenDiffs()
      listenState()
      detachListener()
      handleListenErrors()
    }

    // Query Data
    simpleQueries()
    exampleFilters()
    onlyCapitals()
    chainFilters()
    validRangeFilters()

    // IN Queries
    arrayContainsAnyQueries()
    inQueries()

    // Can't run this since it throws a fatal error
    // invalidRangeFilters()

    orderAndLimit()
    orderAndLimitDesc()
    orderMultiple()
    filterAndOrder()
    validFilterAndOrder()

    // Can't run this since it throws a fatal error
    // invalidFilterAndOrder()

    // Enable Offline
    // Can't run this since it throws a fatal error
    // enableOffline()
    listenToOffline()
    toggleOffline()
    setupCacheSize()

    // Cursors
    simpleCursor()
    snapshotCursor()
    paginate()
    multiCursor()
  }

  func deleteCollection(collection: String) {
    db.collection(collection).getDocuments() { (querySnapshot, err) in
      if let err = err {
        print("Error getting documents: \(err)")
        return
      }

      for document in querySnapshot!.documents {
        print("Deleting \(document.documentID) => \(document.data())")
        document.reference.delete()
      }
    }
  }

  private func setupCacheSize() {
    // [START fs_setup_cache]
    let settings = Firestore.firestore().settings
    // Set cache size to 100 MB
    settings.cacheSettings = PersistentCacheSettings(sizeBytes: 100 * 1024 * 1024 as NSNumber)
    Firestore.firestore().settings = settings
    // [END fs_setup_cache]
  }

  // =======================================================================================
  // ======== https://firebase.google.com/preview/firestore/client/quickstart ==============
  // =======================================================================================

  private func addAdaLovelace() async {
    // [START add_ada_lovelace]
    // Add a new document with a generated ID
    do {
      let ref = try await db.collection("users").addDocument(data: [
        "first": "Ada",
        "last": "Lovelace",
        "born": 1815
      ])
      print("Document added with ID: \(ref.documentID)")
    } catch {
      print("Error adding document: \(error)")
    }
    // [END add_ada_lovelace]
  }

  private func addAlanTuring() async {
    // [START add_alan_turing]
    // Add a second document with a generated ID.
    do {
      let ref = try await db.collection("users").addDocument(data: [
        "first": "Alan",
        "middle": "Mathison",
        "last": "Turing",
        "born": 1912
      ])
      print("Document added with ID: \(ref.documentID)")
    } catch {
      print("Error adding document: \(error)")
    }
    // [END add_alan_turing]
  }

  private func getCollection() async {
    // [START get_collection]
    do {
      let snapshot = try await db.collection("users").getDocuments()
      for document in snapshot.documents {
        print("\(document.documentID) => \(document.data())")
      }
    } catch {
      print("Error getting documents: \(error)")
    }
    // [END get_collection]
  }

  private func listenForUsers() {
    // [START listen_for_users]
    // Listen to a query on a collection.
    //
    // We will get a first snapshot with the initial results and a new
    // snapshot each time there is a change in the results.
    db.collection("users")
      .whereField("born", isLessThan: 1900)
      .addSnapshotListener { querySnapshot, error in
        guard let snapshot = querySnapshot else {
          print("Error retreiving snapshots \(error!)")
          return
        }
        print("Current users born before 1900: \(snapshot.documents.map { $0.data() })")
      }
    // [END listen_for_users]
  }

  // =======================================================================================
  // ======= https://firebase.google.com/preview/firestore/client/structure-data ===========
  // =======================================================================================


  private func demonstrateReferences() {
    // [START doc_reference]
    let alovelaceDocumentRef = db.collection("users").document("alovelace")
    // [END doc_reference]
    print(alovelaceDocumentRef)

    // [START collection_reference]
    let usersCollectionRef = db.collection("users")
    // [END collection_reference]
    print(usersCollectionRef)

    // [START subcollection_reference]
    let messageRef = db
      .collection("rooms").document("roomA")
      .collection("messages").document("message1")
    // [END subcollection_reference]
    print(messageRef)

    // [START path_reference]
    let aLovelaceDocumentReference = db.document("users/alovelace")
    // [END path_reference]
    print(aLovelaceDocumentReference)
  }

  // =======================================================================================
  // ========= https://firebase.google.com/preview/firestore/client/save-data ==============
  // =======================================================================================

  private func setDocument() async {
    // [START set_document]
    // Add a new document in collection "cities"
    do {
      try await db.collection("cities").document("LA").setData([
        "name": "Los Angeles",
        "state": "CA",
        "country": "USA"
      ])
      print("Document successfully written!")
    } catch {
      print("Error writing document: \(error)")
    }
    // [END set_document]
  }

  private func setDocumentWithCodable() {
    // [START set_document_codable]
    let city = City(name: "Los Angeles",
                    state: "CA",
                    country: "USA",
                    isCapital: false,
                    population: 5000000)

    do {
      try db.collection("cities").document("LA").setData(from: city)
    } catch let error {
      print("Error writing city to Firestore: \(error)")
    }
    // [END set_document_codable]
  }

  private func dataTypes() async {
    // [START data_types]
    let docData: [String: Any] = [
      "stringExample": "Hello world!",
      "booleanExample": true,
      "numberExample": 3.14159265,
      "dateExample": Timestamp(date: Date()),
      "arrayExample": [5, true, "hello"],
      "nullExample": NSNull(),
      "objectExample": [
        "a": 5,
        "b": [
          "nested": "foo"
        ]
      ]
    ]
    do {
      try await db.collection("data").document("one").setData(docData)
      print("Document successfully written!")
    } catch {
      print("Error writing document: \(error)")
    }
    // [END data_types]
  }

  private func setData() {
    let data: [String: Any] = [:]

    // [START set_data]
    db.collection("cities").document("new-city-id").setData(data)
    // [END set_data]
  }

  private func addDocument() async {
    // [START add_document]
    // Add a new document with a generated id.
    do {
      let ref = try await db.collection("cities").addDocument(data: [
        "name": "Tokyo",
        "country": "Japan"
      ])
      print("Document added with ID: \(ref.documentID)")
    } catch {
      print("Error adding document: \(error)")
    }
    // [END add_document]
  }

  private func newDocument() {
    // [START new_document]
    let newCityRef = db.collection("cities").document()

    // later...
    newCityRef.setData([
      // [START_EXCLUDE]
      "name": "Some City Name"
      // [END_EXCLUDE]
    ])
    // [END new_document]
  }

  private func updateDocument() async {
    // [START update_document]
    let washingtonRef = db.collection("cities").document("DC")

    // Set the "capital" field of the city 'DC'
    do {
      try await washingtonRef.updateData([
        "capital": true
      ])
      print("Document successfully updated")
    } catch {
      print("Error updating document: \(error)")
    }
    // [END update_document]
  }

  private func updateDocumentArray() {
    // [START update_document_array]
    let washingtonRef = db.collection("cities").document("DC")

    // Atomically add a new region to the "regions" array field.
    washingtonRef.updateData([
      "regions": FieldValue.arrayUnion(["greater_virginia"])
    ])

    // Atomically remove a region from the "regions" array field.
    washingtonRef.updateData([
      "regions": FieldValue.arrayRemove(["east_coast"])
    ])
    // [END update_document_array]
  }

  private func updateDocumentIncrement() {
    // [START update_document-increment]
    let washingtonRef = db.collection("cities").document("DC")

    // Atomically increment the population of the city by 50.
    // Note that increment() with no arguments increments by 1.
    washingtonRef.updateData([
      "population": FieldValue.increment(Int64(50))
    ])
    // [END update_document-increment]
  }

  private func createIfMissing() {
    // [START create_if_missing]
    // Update one field, creating the document if it does not exist.
    db.collection("cities").document("BJ").setData([ "capital": true ], merge: true)
    // [END create_if_missing]
  }

  private func updateDocumentNested() async {
    // [START update_document_nested]
    // Create an initial document to update.
    let frankDocRef = db.collection("users").document("frank")
    do {
      try await frankDocRef.setData([
        "name": "Frank",
        "favorites": [ "food": "Pizza", "color": "Blue", "subject": "recess" ],
        "age": 12
      ])

      // To update age and favorite color:
      try await frankDocRef.updateData([
        "age": 13,
        "favorites.color": "Red"
      ])
      print("Document successfully updated")
    } catch {
      print("Error updating document: \(error)")
    }
    // [END update_document_nested]
  }

  private func deleteDocument() async {
    // [START delete_document]
    do {
      try await db.collection("cities").document("DC").delete()
      print("Document successfully removed!")
    } catch {
      print("Error removing document: \(error)")
    }
    // [END delete_document]
  }

  private func deleteCollection() {
    // [START delete_collection]
    func delete(collection: CollectionReference, batchSize: Int = 100, completion: @escaping (Error?) -> ()) {
      // Limit query to avoid out-of-memory errors on large collections.
      // When deleting a collection guaranteed to fit in memory, batching can be avoided entirely.
      collection.limit(to: batchSize).getDocuments { (docset, error) in
        // An error occurred.
        guard let docset = docset else {
          completion(error)
          return
        }
        // There's nothing to delete.
        guard docset.count > 0 else {
          completion(nil)
          return
        }

        let batch = collection.firestore.batch()
        docset.documents.forEach { batch.deleteDocument($0.reference) }

        batch.commit { (batchError) in
          if let batchError = batchError {
            // Stop the deletion process and handle the error. Some elements
            // may have been deleted.
            completion(batchError)
          } else {
            delete(collection: collection, batchSize: batchSize, completion: completion)
          }
        }
      }
    }
    // [END delete_collection]
  }

  private func deleteField() async {
    // [START delete_field]
    do {

      try await db.collection("cities").document("BJ").updateData([
        "capital": FieldValue.delete(),
      ])
      print("Document successfully updated")
    } catch {
      print("Error updating document: \(error)")
    }
    // [END delete_field]
  }

  private func serverTimestamp() async {
    // [START server_timestamp]
    do {
      try await db.collection("objects").document("some-id").updateData([
        "lastUpdated": FieldValue.serverTimestamp(),
      ])
      print("Document successfully updated")
    } catch {
      print("Error updating document: \(error)")
    }
    // [END server_timestamp]
  }

  private func serverTimestampOptions() {
    // [START server_timestamp_options]
    // Perform an update followed by an immediate read without waiting for the update to
    // complete. Due to the snapshot options we will get two results: one with an estimated
    // timestamp and one with a resolved server timestamp.
    let docRef = db.collection("objects").document("some-id")
    docRef.updateData(["timestamp": FieldValue.serverTimestamp()])

    docRef.addSnapshotListener { (snapshot, error) in
      guard let timestamp = snapshot?.data(with: .estimate)?["timestamp"] else { return }
      guard let pendingWrites = snapshot?.metadata.hasPendingWrites else { return }
      print("Timestamp: \(timestamp), pending: \(pendingWrites)")
    }
    // [END server_timestamp_options]
  }

  private func simpleTransaction() async {
    // [START simple_transaction]
    let sfReference = db.collection("cities").document("SF")

    do {
      let _ = try await db.runTransaction({ (transaction, errorPointer) -> Any? in
        let sfDocument: DocumentSnapshot
        do {
          try sfDocument = transaction.getDocument(sfReference)
        } catch let fetchError as NSError {
          errorPointer?.pointee = fetchError
          return nil
        }

        guard let oldPopulation = sfDocument.data()?["population"] as? Int else {
          let error = NSError(
            domain: "AppErrorDomain",
            code: -1,
            userInfo: [
              NSLocalizedDescriptionKey: "Unable to retrieve population from snapshot \(sfDocument)"
            ]
          )
          errorPointer?.pointee = error
          return nil
        }

        // Note: this could be done without a transaction
        //       by updating the population using FieldValue.increment()
        transaction.updateData(["population": oldPopulation + 1], forDocument: sfReference)
        return nil
      })
      print("Transaction successfully committed!")
    } catch {
      print("Transaction failed: \(error)")
    }
    // [END simple_transaction]
  }

  private func transaction() async {
    // [START transaction]
    let sfReference = db.collection("cities").document("SF")

    do {
      let object = try await db.runTransaction({ (transaction, errorPointer) -> Any? in
        let sfDocument: DocumentSnapshot
        do {
          try sfDocument = transaction.getDocument(sfReference)
        } catch let fetchError as NSError {
          errorPointer?.pointee = fetchError
          return nil
        }

        guard let oldPopulation = sfDocument.data()?["population"] as? Int else {
          let error = NSError(
            domain: "AppErrorDomain",
            code: -1,
            userInfo: [
              NSLocalizedDescriptionKey: "Unable to retrieve population from snapshot \(sfDocument)"
            ]
          )
          errorPointer?.pointee = error
          return nil
        }

        // Note: this could be done without a transaction
        //       by updating the population using FieldValue.increment()
        let newPopulation = oldPopulation + 1
        guard newPopulation <= 1000000 else {
          let error = NSError(
            domain: "AppErrorDomain",
            code: -2,
            userInfo: [NSLocalizedDescriptionKey: "Population \(newPopulation) too big"]
          )
          errorPointer?.pointee = error
          return nil
        }

        transaction.updateData(["population": newPopulation], forDocument: sfReference)
        return newPopulation
      })
      print("Population increased to \(object!)")
    } catch {
      print("Error updating population: \(error)")
    }
    // [END transaction]
  }

  private func writeBatch() async {
    // [START write_batch]
    // Get new write batch
    let batch = db.batch()

    // Set the value of 'NYC'
    let nycRef = db.collection("cities").document("NYC")
    batch.setData([:], forDocument: nycRef)

    // Update the population of 'SF'
    let sfRef = db.collection("cities").document("SF")
    batch.updateData(["population": 1000000 ], forDocument: sfRef)

    // Delete the city 'LA'
    let laRef = db.collection("cities").document("LA")
    batch.deleteDocument(laRef)

    // Commit the batch
    do {
      try await batch.commit()
      print("Batch write succeeded.")
    } catch {
      print("Error writing batch: \(error)")
    }
    // [END write_batch]
  }

  // =======================================================================================
  // ======= https://firebase.google.com/preview/firestore/client/retrieve-data ============
  // =======================================================================================

  private func exampleData() {
    // [START example_data]
    let citiesRef = db.collection("cities")

    citiesRef.document("SF").setData([
      "name": "San Francisco",
      "state": "CA",
      "country": "USA",
      "capital": false,
      "population": 860000,
      "regions": ["west_coast", "norcal"]
    ])
    citiesRef.document("LA").setData([
      "name": "Los Angeles",
      "state": "CA",
      "country": "USA",
      "capital": false,
      "population": 3900000,
      "regions": ["west_coast", "socal"]
    ])
    citiesRef.document("DC").setData([
      "name": "Washington D.C.",
      "country": "USA",
      "capital": true,
      "population": 680000,
      "regions": ["east_coast"]
    ])
    citiesRef.document("TOK").setData([
      "name": "Tokyo",
      "country": "Japan",
      "capital": true,
      "population": 9000000,
      "regions": ["kanto", "honshu"]
    ])
    citiesRef.document("BJ").setData([
      "name": "Beijing",
      "country": "China",
      "capital": true,
      "population": 21500000,
      "regions": ["jingjinji", "hebei"]
    ])
    // [END example_data]
  }

  private func exampleDataCollectionGroup() {
    // [START fs_collection_group_query_data_setup]
    let citiesRef = db.collection("cities")

    var data = ["name": "Golden Gate Bridge", "type": "bridge"]
    citiesRef.document("SF").collection("landmarks").addDocument(data: data)

    data = ["name": "Legion of Honor", "type": "museum"]
    citiesRef.document("SF").collection("landmarks").addDocument(data: data)

    data = ["name": "Griffith Park", "type": "park"]
    citiesRef.document("LA").collection("landmarks").addDocument(data: data)

    data = ["name": "The Getty", "type": "museum"]
    citiesRef.document("LA").collection("landmarks").addDocument(data: data)

    data = ["name": "Lincoln Memorial", "type": "memorial"]
    citiesRef.document("DC").collection("landmarks").addDocument(data: data)

    data = ["name": "National Air and Space Museum", "type": "museum"]
    citiesRef.document("DC").collection("landmarks").addDocument(data: data)

    data = ["name": "Ueno Park", "type": "park"]
    citiesRef.document("TOK").collection("landmarks").addDocument(data: data)

    data = ["name": "National Museum of Nature and Science", "type": "museum"]
    citiesRef.document("TOK").collection("landmarks").addDocument(data: data)

    data = ["name": "Jingshan Park", "type": "park"]
    citiesRef.document("BJ").collection("landmarks").addDocument(data: data)

    data = ["name": "Beijing Ancient Observatory", "type": "museum"]
    citiesRef.document("BJ").collection("landmarks").addDocument(data: data)
    // [END fs_collection_group_query_data_setup]
  }

  private func getDocument() async {
    // [START get_document]
    let docRef = db.collection("cities").document("SF")

    do {
      let document = try await docRef.getDocument()
      if document.exists {
        let dataDescription = document.data().map(String.init(describing:)) ?? "nil"
        print("Document data: \(dataDescription)")
      } else {
        print("Document does not exist")
      }
    } catch {
      print("Error getting document: \(error)")
    }
    // [END get_document]
  }

  private func getDocumentWithOptions() async {
    // [START get_document_options]
    let docRef = db.collection("cities").document("SF")

    do {
      // Force the SDK to fetch the document from the cache. Could also specify
      // FirestoreSource.server or FirestoreSource.default.
      let document = try await docRef.getDocument(source: .cache)
      if document.exists {
        let dataDescription = document.data().map(String.init(describing:)) ?? "nil"
        print("Cached document data: \(dataDescription)")
      } else {
        print("Document does not exist in cache")
      }
    } catch {
      print("Error getting document: \(error)")
    }
    // [END get_document_options]
  }

  private func customClassGetDocument() async {
    // [START custom_type]
    let docRef = db.collection("cities").document("BJ")

    do {
      let city = try await docRef.getDocument(as: City.self)
      print("City: \(city)")
    } catch {
      print("Error decoding city: \(error)")
    }
    // [END custom_type]
  }

  private func listenDocument() {
    // [START listen_document]
    db.collection("cities").document("SF")
      .addSnapshotListener { documentSnapshot, error in
        guard let document = documentSnapshot else {
          print("Error fetching document: \(error!)")
          return
        }
        guard let data = document.data() else {
          print("Document data was empty.")
          return
        }
        print("Current data: \(data)")
      }
    // [END listen_document]
  }

  private func listenDocumentLocal() {
    // [START listen_document_local]
    db.collection("cities").document("SF")
      .addSnapshotListener { documentSnapshot, error in
        guard let document = documentSnapshot else {
          print("Error fetching document: \(error!)")
          return
        }
        let source = document.metadata.hasPendingWrites ? "Local" : "Server"
        print("\(source) data: \(document.data() ?? [:])")
      }
    // [END listen_document_local]
  }

  private func listenWithMetadata() {
    // [START listen_with_metadata]
    // Listen to document metadata.
    db.collection("cities").document("SF")
      .addSnapshotListener(includeMetadataChanges: true) { documentSnapshot, error in
        // ...
      }
    // [END listen_with_metadata]
  }

  private func getMultiple() async {
    // [START get_multiple]
    do {
      let querySnapshot = try await db.collection("cities").whereField("capital", isEqualTo: true)
        .getDocuments()
      for document in querySnapshot.documents {
        print("\(document.documentID) => \(document.data())")
      }
    } catch {
      print("Error getting documents: \(error)")
    }
    // [END get_multiple]
  }

  private func getMultipleAll() async {
    // [START get_multiple_all]
    do {
      let querySnapshot = try await db.collection("cities").getDocuments()
      for document in querySnapshot.documents {
        print("\(document.documentID) => \(document.data())")
      }
    } catch {
      print("Error getting documents: \(error)")
    }
    // [END get_multiple_all]
  }

  private func getMultipleAllSubcollection() async {
    // [START get_multiple_all_subcollection]
    do {
      let querySnapshot = try await db.collection("cities/SF/landmarks").getDocuments()
      for document in querySnapshot.documents {
        print("\(document.documentID) => \(document.data())")
      }
    } catch {
      print("Error getting documents: \(error)")
    }
    // [END get_multiple_all_subcollection]
  }

  private func listenMultiple() {
    // [START listen_multiple]
    db.collection("cities").whereField("state", isEqualTo: "CA")
      .addSnapshotListener { querySnapshot, error in
        guard let documents = querySnapshot?.documents else {
          print("Error fetching documents: \(error!)")
          return
        }
        let cities = documents.compactMap { $0["name"] }
        print("Current cities in CA: \(cities)")
      }
    // [END listen_multiple]
  }

  private func listenDiffs() {
    // [START listen_diffs]
    db.collection("cities").whereField("state", isEqualTo: "CA")
      .addSnapshotListener { querySnapshot, error in
        guard let snapshot = querySnapshot else {
          print("Error fetching snapshots: \(error!)")
          return
        }
        snapshot.documentChanges.forEach { diff in
          if (diff.type == .added) {
            print("New city: \(diff.document.data())")
          }
          if (diff.type == .modified) {
            print("Modified city: \(diff.document.data())")
          }
          if (diff.type == .removed) {
            print("Removed city: \(diff.document.data())")
          }
        }
      }
    // [END listen_diffs]
  }

  private func listenState() {
    // [START listen_state]
    db.collection("cities").whereField("state", isEqualTo: "CA")
      .addSnapshotListener { querySnapshot, error in
        guard let snapshot = querySnapshot else {
          print("Error fetching documents: \(error!)")
          return
        }
        snapshot.documentChanges.forEach { diff in
          if (diff.type == .added) {
            print("New city: \(diff.document.data())")
          }
        }

        if !snapshot.metadata.isFromCache {
          print("Synced with server state.")
        }
      }
    // [END listen_state]
  }

  private func detachListener() {
    // [START detach_listener]
    let listener = db.collection("cities").addSnapshotListener { querySnapshot, error in
      // [START_EXCLUDE]
      // [END_EXCLUDE]
    }

    // ...

    // Stop listening to changes
    listener.remove()
    // [END detach_listener]
  }

  private func handleListenErrors() {
    // [START handle_listen_errors]
    db.collection("cities")
      .addSnapshotListener { querySnapshot, error in
        if let error = error {
          print("Error retreiving collection: \(error)")
        }
      }
    // [END handle_listen_errors]
  }

  // =======================================================================================
  // ======== https://firebase.google.com/preview/firestore/client/query-data ==============
  // =======================================================================================

  private func simpleQueries() {
    // [START simple_queries]
    // Create a reference to the cities collection
    let citiesRef = db.collection("cities")

    // Create a query against the collection.
    let query = citiesRef.whereField("state", isEqualTo: "CA")
    // [END simple_queries]

    // [START simple_query_not_equal]
    let notEqualQuery = citiesRef.whereField("capital", isNotEqualTo: false)
    // [END simple_query_not_equal]

    print(query)
  }

  private func exampleFilters() {
    let citiesRef = db.collection("cities")

    // [START example_filters]
    let stateQuery = citiesRef.whereField("state", isEqualTo: "CA")
    let populationQuery = citiesRef.whereField("population", isLessThan: 100000)
    let nameQuery = citiesRef.whereField("name", isGreaterThanOrEqualTo: "San Francisco")
    // [END example_filters]
  }

  private func onlyCapitals() {
    // [START only_capitals]
    let capitalCities = db.collection("cities").whereField("capital", isEqualTo: true)
    // [END only_capitals]
    print(capitalCities)
  }

  private func arrayContainsFilter() {
    let citiesRef = db.collection("cities")

    // [START array_contains_filter]
    citiesRef
      .whereField("regions", arrayContains: "west_coast")
    // [END array_contains_filter]
  }

  private func chainFilters() {
    let citiesRef = db.collection("cities")

    // [START chain_filters]
    citiesRef
      .whereField("state", isEqualTo: "CO")
      .whereField("name", isEqualTo: "Denver")
    citiesRef
      .whereField("state", isEqualTo: "CA")
      .whereField("population", isLessThan: 1000000)
    // [END chain_filters]
  }

  private func validRangeFilters() {
    let citiesRef = db.collection("cities")

    // [START valid_range_filters]
    citiesRef
      .whereField("state", isGreaterThanOrEqualTo: "CA")
      .whereField("state", isLessThanOrEqualTo: "IN")
    citiesRef
      .whereField("state", isEqualTo: "CA")
      .whereField("population", isGreaterThan: 1000000)
    // [END valid_range_filters]
  }

  private func invalidRangeFilters() throws {
    let citiesRef = db.collection("cities")

    // [START invalid_range_filters]
    citiesRef
      .whereField("state", isGreaterThanOrEqualTo: "CA")
      .whereField("population", isGreaterThan: 1000000)
    // [END invalid_range_filters]
  }

  private func orderAndLimit() {
    let citiesRef = db.collection("cities")

    // [START order_and_limit]
    citiesRef.order(by: "name").limit(to: 3)
    // [END order_and_limit]
  }

  private func orderAndLimitDesc() {
    let citiesRef = db.collection("cities")

    // [START order_and_limit_desc]
    citiesRef.order(by: "name", descending: true).limit(to: 3)
    // [END order_and_limit_desc]
  }

  private func orderMultiple() {
    let citiesRef = db.collection("cities")

    // [START order_multiple]
    citiesRef
      .order(by: "state")
      .order(by: "population", descending: true)
    // [END order_multiple]
  }

  private func filterAndOrder() {
    let citiesRef = db.collection("cities")

    // [START filter_and_order]
    citiesRef
      .whereField("population", isGreaterThan: 100000)
      .order(by: "population")
      .limit(to: 2)
    // [END filter_and_order]
  }

  private func validFilterAndOrder() {
    let citiesRef = db.collection("cities")

    // [START valid_filter_and_order]
    citiesRef
      .whereField("population", isGreaterThan: 100000)
      .order(by: "population")
    // [END valid_filter_and_order]
  }

  private func invalidFilterAndOrder() throws {
    let citiesRef = db.collection("cities")

    // [START invalid_filter_and_order]
    citiesRef
      .whereField("population", isGreaterThan: 100000)
      .order(by: "country")
    // [END invalid_filter_and_order]
  }

  private func arrayContainsAnyQueries() {
    // [START array_contains_any_filter]
    let citiesRef = db.collection("cities")
    citiesRef.whereField("regions", arrayContainsAny: ["west_coast", "east_coast"])
    // [END array_contains_any_filter]
  }

  private func inQueries() {
    // [START in_filter]
    let citiesRef = db.collection("cities")

    citiesRef.whereField("country", in: ["USA", "Japan"])
    // [END in_filter]

    // [START in_filter_with_array]
    citiesRef.whereField("regions", in: [["west_coast"], ["east_coast"]])
    // [END in_filter_with_array]

    // [START not_in_filter]
    citiesRef.whereField("country", notIn: ["USA", "Japan"])
    // [END not_in_filter]
  }

  // =======================================================================================
  // ====== https://firebase.google.com/preview/firestore/client/enable-offline ============
  // =======================================================================================

  private func enableOffline() {
    // [START enable_offline]
    let settings = FirestoreSettings()

    // Use memory-only cache
    settings.cacheSettings =
    MemoryCacheSettings(garbageCollectorSettings: MemoryLRUGCSettings())

    // Use persistent disk cache, with 100 MB cache size
    settings.cacheSettings = PersistentCacheSettings(sizeBytes: 100 * 1024 * 1024 as NSNumber)

    // Any additional options
    // ...

    // Enable offline data persistence
    let db = Firestore.firestore()
    db.settings = settings
    // [END enable_offline]
  }

  private func listenToOffline() {
    let db = Firestore.firestore()
    // [START listen_to_offline]
    // Listen to metadata updates to receive a server snapshot even if
    // the data is the same as the cached data.
    db.collection("cities").whereField("state", isEqualTo: "CA")
      .addSnapshotListener(includeMetadataChanges: true) { querySnapshot, error in
        guard let snapshot = querySnapshot else {
          print("Error retreiving snapshot: \(error!)")
          return
        }

        for diff in snapshot.documentChanges {
          if diff.type == .added {
            print("New city: \(diff.document.data())")
          }
        }

        let source = snapshot.metadata.isFromCache ? "local cache" : "server"
        print("Metadata: Data fetched from \(source)")
      }
    // [END listen_to_offline]
  }

  private func toggleOffline() {
    // [START disable_network]
    Firestore.firestore().disableNetwork { (error) in
      // Do offline things
      // ...
    }
    // [END disable_network]

    // [START enable_network]
    Firestore.firestore().enableNetwork { (error) in
      // Do online things
      // ...
    }
    // [END enable_network]
  }

  // =======================================================================================
  // ====== https://firebase.google.com/preview/firestore/client/cursors ===================
  // =======================================================================================

  private func simpleCursor() {
    let db = Firestore.firestore()

    // [START cursor_greater_than]
    // Get all cities with population over one million, ordered by population.
    db.collection("cities")
      .order(by: "population")
      .start(at: [1000000])
    // [END cursor_greater_than]

    // [START cursor_less_than]
    // Get all cities with population less than one million, ordered by population.
    db.collection("cities")
      .order(by: "population")
      .end(at: [1000000])
    // [END cursor_less_than]
  }

  private func snapshotCursor() {
    let db = Firestore.firestore()

    // [START snapshot_cursor]
    db.collection("cities")
      .document("SF")
      .addSnapshotListener { (document, error) in
        guard let document = document else {
          print("Error retreving cities: \(error.debugDescription)")
          return
        }

        // Get all cities with a population greater than or equal to San Francisco.
        let sfSizeOrBigger = db.collection("cities")
          .order(by: "population")
          .start(atDocument: document)
      }
    // [END snapshot_cursor]
  }

  private func paginate() {
    let db = Firestore.firestore()

    // [START paginate]
    // Construct query for first 25 cities, ordered by population
    let first = db.collection("cities")
      .order(by: "population")
      .limit(to: 25)

    first.addSnapshotListener { (snapshot, error) in
      guard let snapshot = snapshot else {
        print("Error retreving cities: \(error.debugDescription)")
        return
      }

      guard let lastSnapshot = snapshot.documents.last else {
        // The collection is empty.
        return
      }

      // Construct a new query starting after this document,
      // retrieving the next 25 cities.
      let next = db.collection("cities")
        .order(by: "population")
        .start(afterDocument: lastSnapshot)

      // Use the query for pagination.
      // ...
    }
    // [END paginate]
  }

  private func multiCursor() {
    let db = Firestore.firestore()

    // [START multi_cursor]
    // Will return all Springfields
    db.collection("cities")
      .order(by: "name")
      .order(by: "state")
      .start(at: ["Springfield"])

    // Will return "Springfield, Missouri" and "Springfield, Wisconsin"
    db.collection("cities")
      .order(by: "name")
      .order(by: "state")
      .start(at: ["Springfield", "Missouri"])
    // [END multi_cursor]
  }

  private func collectionGroupQuery() {
    // [START fs_collection_group_query]
    db.collectionGroup("landmarks").whereField("type", isEqualTo: "museum").getDocuments { (snapshot, error) in
      // [START_EXCLUDE]
      print(snapshot?.documents.count ?? 0)
      // [END_EXCLUDE]
    }
    // [END fs_collection_group_query]
  }

  private func emulatorSettings() {
    // [START fs_emulator_connect]
    let settings = Firestore.firestore().settings
    settings.host = "127.0.0.1:8080"
    settings.cacheSettings = MemoryCacheSettings()
    settings.isSSLEnabled = false
    Firestore.firestore().settings = settings
    // [END fs_emulator_connect]
  }

  // MARK: Aggregation queries
  private func countAggregateCollection() async {
    // [START count_aggregate_collection]
    let query = db.collection("cities")
    let countQuery = query.count
    do {
      let snapshot = try await countQuery.getAggregation(source: .server)
      print(snapshot.count)
    } catch {
      print(error)
    }
    // [END count_aggregate_collection]
  }

  private func countAggregateQuery() async {
    // [START count_aggregate_query]
    let query = db.collection("cities").whereField("state", isEqualTo: "CA")
    let countQuery = query.count
    do {
      let snapshot = try await countQuery.getAggregation(source: .server)
      print(snapshot.count)
    } catch {
      print(error)
    }
    // [END count_aggregate_query]
  }
  
  private func sumAggregateCollection() async {
    // [START sum_aggregate_collection]
    let query = db.collection("cities")
    let aggregateQuery = query.aggregate([AggregateField.sum("population")])
    do {
      let snapshot = try await aggregateQuery.getAggregation(source: .server)
      print(snapshot.get(AggregateField.sum("population")))
    } catch {
      print(error)
    }
    // [END sum_aggregate_collection]
  }
  
  private func sumAggregateQuery() async {
    // [START sum_aggregate_query]
    let query = db.collection("cities").whereField("capital", isEqualTo: true)
    let aggregateQuery = query.aggregate([AggregateField.sum("population")])
    do {
      let snapshot = try await aggregateQuery.getAggregation(source: .server)
      print(snapshot.get(AggregateField.sum("population")))
    } catch {
      print(error)
    }
    // [END sum_aggregate_query]
  }
  
  private func averageAggregateCollection() async {
    // [START average_aggregate_collection]
    let query = db.collection("cities")
    let aggregateQuery = query.aggregate([AggregateField.average("population")])
    do {
      let snapshot = try await aggregateQuery.getAggregation(source: .server)
      print(snapshot.get(AggregateField.average("population")))
    } catch {
      print(error)
    }
    // [END average_aggregate_collection]
  }
  
  private func averageAggregateQuery() async {
    // [START average_aggregate_query]
    let query = db.collection("cities").whereField("capital", isEqualTo: true)
    let aggregateQuery = query.aggregate([AggregateField.average("population")])
    do {
      let snapshot = try await aggregateQuery.getAggregation(source: .server)
      print(snapshot.get(AggregateField.average("population")))
    } catch {
      print(error)
    }
    // [END average_aggregate_query]
  }
  
  private func multiAggregateCollection() async {
    // [START multi_aggregate_collection]
    let query = db.collection("cities")
    let aggregateQuery = query.aggregate([
      AggregateField.count(),
      AggregateField.sum("population"),
      AggregateField.average("population")])
    do {
      let snapshot = try await aggregateQuery.getAggregation(source: .server)
      print("Count: \(snapshot.get(AggregateField.count()))")
      print("Sum: \(snapshot.get(AggregateField.sum("population")))")
      print("Average: \(snapshot.get(AggregateField.average("population")))")
    } catch {
      print(error)
    }
    // [END multi_aggregate_collection]
  }

  private func orQuery() {
    // [START or_query]
    let query = db.collection("cities").whereFilter(Filter.andFilter([
      Filter.whereField("state", isEqualTo: "CA"),
      Filter.orFilter([
        Filter.whereField("capital", isEqualTo: true),
        Filter.whereField("population", isGreaterOrEqualTo: 1000000)
      ])
    ]))
    // [END or_query]
  }

  private func orQueryDisjunctions() {
    let collection = db.collection("cities")

    // [START one_disjunction]
    collection.whereField("a", isEqualTo: 1)
    // [END one_disjunction]

    // [START two_disjunctions]
    collection.whereFilter(Filter.orFilter([
      Filter.whereField("a", isEqualTo: 1),
      Filter.whereField("b", isEqualTo: 2)
    ]))
    // [END two_disjunctions]

    // [START four_disjunctions]
    collection.whereFilter(Filter.orFilter([
      Filter.andFilter([
        Filter.whereField("a", isEqualTo: 1),
        Filter.whereField("c", isEqualTo: 3)
      ]),
      Filter.andFilter([
        Filter.whereField("a", isEqualTo: 1),
        Filter.whereField("d", isEqualTo: 4)
      ]),
      Filter.andFilter([
        Filter.whereField("b", isEqualTo: 2),
        Filter.whereField("c", isEqualTo: 3)
      ]),
      Filter.andFilter([
        Filter.whereField("b", isEqualTo: 2),
        Filter.whereField("d", isEqualTo: 4)
      ])
    ]))
    // [END four_disjunctions]

    // [START four_disjunctions_compact]
    collection.whereFilter(Filter.andFilter([
      Filter.orFilter([
        Filter.whereField("a", isEqualTo: 1),
        Filter.whereField("b", isEqualTo: 2)
      ]),
      Filter.orFilter([
        Filter.whereField("c", isEqualTo: 3),
        Filter.whereField("d", isEqualTo: 4)
      ]),
    ]))
    // [END four_disjunctions_compact]

    // [START 20_disjunctions]
    collection.whereFilter(Filter.orFilter([
      Filter.whereField("a", in: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
      Filter.whereField("b", in: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    ]))
    // [END 20_disjunctions]

    // [START 10_disjunctions]
    collection.whereFilter(Filter.andFilter([
      Filter.whereField("a", in: [1, 2, 3, 4, 5]),
      Filter.orFilter([
        Filter.whereField("b", isEqualTo: 2),
        Filter.whereField("c", isEqualTo: 3)
      ])
    ]))
    // [END 10_disjunctions]
  }

  // This method crashes, so don't include it in the smoketest.
  func illegalDisjunctions() {
    let collection = db.collection("cities")

    // [START 50_disjunctions]
    collection.whereFilter(Filter.andFilter([
      Filter.whereField("a", in: [1, 2, 3, 4, 5]),
      Filter.whereField("b", in: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    ]))
    // [END 50_disjunctions]
  }

}

// [START codable_struct]
public struct City: Codable, Sendable {

  let name: String
  let state: String?
  let country: String?
  let isCapital: Bool?
  let population: Int64?

  enum CodingKeys: String, CodingKey {
    case name
    case state
    case country
    case isCapital = "capital"
    case population
  }

}
// [END codable_struct]