path: root/Sora/Data/Settings/SettingsManager.swift

// swiftlint:disable file_length

import SwiftUI

@MainActor
class SettingsManager: ObservableObject {  // swiftlint:disable:this type_body_length
  // MARK: - Stored Properties
  @AppStorage("detailViewType")
  var detailViewQuality: BooruPostFileType = .original

  @AppStorage("thumbnailQuality")
  private var _thumbnailQuality: BooruPostFileType = .preview

  @AppStorage("searchSuggestionsMode")
  var searchSuggestionsMode: SettingsSearchSuggestionsMode = .disabled

  @AppStorage("thumbnailGridColumns")
  var thumbnailGridColumns = 2

  @AppStorage("enableShareShortcut")
  var enableShareShortcut = false

  @AppStorage("displayDetailsInformationBar")
  var displayDetailsInformationBar = true

  @AppStorage("preloadedCarouselImages")
  var preloadedCarouselImages = 3

  @AppStorage("enableSync")
  var enableSync: Bool = false

  @AppStorage("alternativeThumbnailGrid")
  var alternativeThumbnailGrid = false

  @AppStorage("uniformThumbnailGrid")
  private var _uniformThumbnailGrid: Bool = false

  @preconcurrency private var syncObservation: (any NSObjectProtocol & Sendable)?

  #if os(macOS)
    @AppStorage("saveTagsToFile")
    var saveTagsToFile = false
  #endif

  // MARK: - Private Properties
  private var bookmarksCache: [SettingsBookmark] = []
  private var searchHistoryCache: [BooruSearchQuery] = []
  private var blurRatingsCache: [BooruRating] = []
  private var displayRatingsCache: [BooruRating] = []
  private var uniformThumbnailGridCache: Bool = false
  private var thumbnailQualityCache: BooruPostFileType = .preview

  // MARK: - Codable Properties
  @AppStorage("bookmarks")
  private var bookmarksData = Data()

  @AppStorage("displayRatings")
  private var displayRatingsData = SettingsManager.encode(BooruRating.allCases) ?? Data()

  @AppStorage("blurRatings")
  private var blurRatingsData = SettingsManager.encode([.explicit as BooruRating]) ?? Data()

  @AppStorage("searchHistory")
  private var searchHistoryData = Data()

  @AppStorage("preferredBooru")
  private var preferredBooruData = Data()

  @AppStorage("customProviders")
  private var customProvidersData = Data()

  @AppStorage("folders")
  private var foldersData = Data()

  @AppStorage("providerCredentials")
  private var providerCredentialsData = Data()

  // MARK: - Computed Properties
  var bookmarks: [SettingsBookmark] {
    get { bookmarksCache }

    set {
      syncableData(
        key: "bookmarks",
        localData: $bookmarksData,
        newValue: newValue
      ) { $0.sorted { $0.date > $1.date } }
      loadBookmarksCache()
      backupBookmarks()
    }
  }

  var uniformThumbnailGrid: Bool {
    get { uniformThumbnailGridCache }

    set {
      _uniformThumbnailGrid = newValue
      uniformThumbnailGridCache = newValue
    }
  }

  var thumbnailQuality: BooruPostFileType {
    get { thumbnailQualityCache }

    set {
      _thumbnailQuality = newValue
      thumbnailQualityCache = newValue
    }
  }

  var displayRatings: [BooruRating] {
    get { displayRatingsCache }

    set {
      displayRatingsData = Self.encode(newValue) ?? displayRatingsData

      loadDisplayRatingsCache()
    }
  }

  var blurRatings: [BooruRating] {
    get { blurRatingsCache }

    set {
      blurRatingsData = Self.encode(newValue) ?? blurRatingsData

      loadBlurRatingsCache()
    }
  }

  var searchHistory: [BooruSearchQuery] {
    get { searchHistoryCache }

    set {
      syncableData(
        key: "searchHistory",
        localData: $searchHistoryData,
        newValue: newValue,
      ) { $0.sorted { $0.date > $1.date } }
      loadSearchHistoryCache()
    }
  }

  var preferredBooru: BooruProvider {
    get {
      Self.decode(BooruProvider.self, from: preferredBooruData) ?? .safebooru
    }

    set { preferredBooruData = Self.encode(newValue) ?? preferredBooruData }
  }

  var customProviders: [BooruProviderCustom] {
    get {
      syncableData(
        key: "customProviders",
        localData: customProvidersData,
        sort: { $0 },
        identifier: { $0.id }
      )
    }

    set {
      syncableData(
        key: "customProviders",
        localData: $customProvidersData,
        newValue: newValue,
      ) { $0 }
    }
  }

  var folders: [SettingsFolder] {
    get {
      syncableData(
        key: "folders",
        localData: foldersData,
        sort: { $0 },
        identifier: { $0.id }
      )
    }

    set {
      syncableData(
        key: "folders",
        localData: $foldersData,
        newValue: newValue,
      ) { $0 }
    }
  }

  // MARK: Provider Credentials
  var providerCredentials: [BooruProviderCredentials] {
    get {
      syncableData(
        key: "providerAPIKeys",
        localData: providerCredentialsData,
        sort: { $0 },
        identifier: { $0.id }
      )
    }

    set {
      let existingCredentials: [BooruProviderCredentials] =
        Self.decode([BooruProviderCredentials].self, from: providerCredentialsData) ?? []
      let rawCredentials = newValue.map { credentials in
        (provider: credentials.provider, apiKey: credentials.apiKey, userID: credentials.userID)
      }
      let mergedCredentials = BooruProviderCredentials.from(
        rawCredentials, existingCredentials: existingCredentials
      )

      syncableData(
        key: "providerAPIKeys",
        localData: $providerCredentialsData,
        newValue: mergedCredentials,
      ) { $0 }
    }
  }

  private func mergedCredentialValues<Value>(
    extract: (BooruProviderCredentials) -> Value,
    isDefault: (Value) -> Bool
  ) -> [BooruProvider: Value] {
    providerCredentials.reduce(into: [BooruProvider: Value]()) { dictionary, credentials in
      let key = credentials.provider
      let value = extract(credentials)

      if dictionary[key] == nil {
        dictionary[key] = value
      } else if isDefault(dictionary[key]!) && !isDefault(value) {
        dictionary[key] = value
      }
    }
  }

  var providerAPIKeys: [BooruProvider: String] {
    mergedCredentialValues(
      extract: { $0.apiKey },
      isDefault: { $0.isEmpty }
    )
  }

  var providerUserIDs: [BooruProvider: Int] {
    mergedCredentialValues(
      extract: { $0.userID },
      isDefault: { $0 == 0 }
    )
  }

  // MARK: - Initialisation
  init() {
    syncObservation = NotificationCenter.default.addObserver(
      forName: NSUbiquitousKeyValueStore.didChangeExternallyNotification,
      object: NSUbiquitousKeyValueStore.default,
      queue: .main
    ) { [weak self] _ in
      Task { @MainActor in
        self?.syncFromCloud()
      }
    }

    loadBookmarksCache()
    loadSearchHistoryCache()
    loadDisplayRatingsCache()
    loadBlurRatingsCache()

    uniformThumbnailGridCache = _uniformThumbnailGrid
    thumbnailQualityCache = _thumbnailQuality
  }

  // MARK: - Private Helpers
  private static func encode<T: Encodable>(_ value: T) -> Data? {
    try? JSONEncoder().encode(value)
  }

  private static func decode<T: Decodable>(_ type: T.Type, from data: Data) -> T? {
    try? JSONDecoder().decode(type, from: data)
  }

  private func syncableData<T: Codable>(
    key: String,
    localData: Data,
    sort: ([T]) -> [T],
    identifier: (T) -> UUID
  ) -> [T] {
    if enableSync {
      if let iCloudData = NSUbiquitousKeyValueStore.default.data(forKey: key) {
        if let iCloudValues = Self.decode([T].self, from: iCloudData) {
          let localValues = Self.decode([T].self, from: localData) ?? []
          var seenValues = Set<UUID>()
          let mergedValues = (localValues + iCloudValues).filter { value in
            seenValues.insert(identifier(value)).inserted
          }

          return sort(mergedValues)
        }
      }
    }

    let localValues = Self.decode([T].self, from: localData) ?? []

    return sort(localValues)
  }

  private func syncableData<T: Codable>(
    key: String,
    localData: Binding<Data>,
    newValue: [T],
    sort: ([T]) -> [T]
  ) {
    let sortedValues = sort(newValue)

    localData.wrappedValue = Self.encode(sortedValues) ?? Data()

    if enableSync {
      NSUbiquitousKeyValueStore.default.set(Self.encode(sortedValues), forKey: key)
      NSUbiquitousKeyValueStore.default.synchronize()
    }
  }

  private func backupBookmarks() {
    guard
      let cachesDirectory = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)
        .first
    else { return }
    let backupDirectory = cachesDirectory.appendingPathComponent("bookmarks_backups")
    let fileManager = FileManager.default

    try? fileManager.createDirectory(at: backupDirectory, withIntermediateDirectories: true)

    let timestamp = Int(Date().timeIntervalSince1970)
    let backupFile = backupDirectory.appendingPathComponent("bookmarks_backup_\(timestamp).json")

    if let data = Self.encode(self.bookmarksCache) {
      try? data.write(to: backupFile)
    }

    if let files = try? fileManager.contentsOfDirectory(
      at: backupDirectory,
      includingPropertiesForKeys: [.contentModificationDateKey],
      options: .skipsHiddenFiles
    ) {
      let jsonBackups = files.filter { file in
        file.lastPathComponent.hasPrefix("bookmarks_backup_") && file.pathExtension == "json"
      }
      let sortedBackups = jsonBackups.sorted { firstFile, secondFile in
        let firstDate =
          (try? firstFile.resourceValues(forKeys: [.contentModificationDateKey])
            .contentModificationDate)
          ?? .distantPast
        let secondDate =
          (try? secondFile.resourceValues(forKeys: [.contentModificationDateKey])
            .contentModificationDate)
          ?? .distantPast

        return firstDate > secondDate
      }

      if sortedBackups.count > 10 {
        for url in sortedBackups[10...] {
          try? fileManager.removeItem(at: url)
        }
      }
    }
  }

  // MARK: Cache Loaders
  private func loadCache<T: Decodable & Sendable>(
    from data: Data,
    sort: @escaping ([T]) -> [T],
    assign: @escaping ([T]) -> Void
  ) {
    let decoded = Self.decode([T].self, from: data) ?? []
    let sorted = sort(decoded)

    assign(sorted)
  }

  private func loadBookmarksCache() {
    loadCache(
      from: bookmarksData,
      sort: { $0.sorted { $0.date > $1.date } },
      assign: { [weak self] in self?.bookmarksCache = $0 }
    )
  }

  private func loadSearchHistoryCache() {
    loadCache(
      from: searchHistoryData,
      sort: { $0.sorted { $0.date > $1.date } },
      assign: { [weak self] in self?.searchHistoryCache = $0 }
    )
  }

  private func loadDisplayRatingsCache() {
    loadCache(
      from: displayRatingsData,
      sort: { $0 },
      assign: { [weak self] in self?.displayRatingsCache = $0 }
    )
  }

  private func loadBlurRatingsCache() {
    loadCache(
      from: blurRatingsData,
      sort: { $0 },
      assign: { [weak self] in self?.blurRatingsCache = $0 }
    )
  }

  // MARK: - Public Methods
  func appendToSearchHistory(_ query: BooruSearchQuery) {
    self.searchHistory.append(query)
  }

  func resetToDefaults() {
    detailViewQuality = .original
    thumbnailQuality = .preview
    searchSuggestionsMode = .disabled
    thumbnailGridColumns = 2
    preferredBooru = .safebooru
    enableShareShortcut = false
    displayRatings = BooruRating.allCases
    blurRatings = [.explicit]
    displayDetailsInformationBar = true
    preloadedCarouselImages = 3

    #if os(macOS)
      saveTagsToFile = false
    #endif
  }

  func syncFromCloud() {
    if self.enableSync {
      if let data = NSUbiquitousKeyValueStore.default.data(forKey: "bookmarks") {
        self.bookmarksData = data
      }

      if let data = NSUbiquitousKeyValueStore.default.data(forKey: "searchHistory") {
        self.searchHistoryData = data
      }

      if let data = NSUbiquitousKeyValueStore.default.data(forKey: "customProviders") {
        self.customProvidersData = data
      }

      loadBookmarksCache()
      loadSearchHistoryCache()
      self.objectWillChange.send()
    }
  }

  func syncToCloud() {
    if enableSync {
      // Merge bookmarks
      var iCloudBookmarks: [SettingsBookmark] = []

      if let iCloudData = NSUbiquitousKeyValueStore.default.data(forKey: "bookmarks") {
        iCloudBookmarks = Self.decode([SettingsBookmark].self, from: iCloudData) ?? []
      }

      let localBookmarks = Self.decode([SettingsBookmark].self, from: bookmarksData) ?? []
      let mergedBookmarks = Array(Set(localBookmarks + iCloudBookmarks))
        .sorted { $0.date > $1.date }

      NSUbiquitousKeyValueStore.default.set(Self.encode(mergedBookmarks), forKey: "bookmarks")

      bookmarksData = Self.encode(mergedBookmarks) ?? Data()

      // Merge search history
      var iCloudHistory: [BooruSearchQuery] = []

      if let iCloudData = NSUbiquitousKeyValueStore.default.data(forKey: "searchHistory") {
        iCloudHistory = Self.decode([BooruSearchQuery].self, from: iCloudData) ?? []
      }

      let localHistory = Self.decode([BooruSearchQuery].self, from: searchHistoryData) ?? []
      let mergedHistory = Array(Set(localHistory + iCloudHistory))
        .sorted { $0.date > $1.date }

      NSUbiquitousKeyValueStore.default.set(Self.encode(mergedHistory), forKey: "searchHistory")

      searchHistoryData = Self.encode(mergedHistory) ?? Data()

      // Merge custom providers
      var iCloudProviders: [BooruProviderCustom] = []

      if let iCloudData = NSUbiquitousKeyValueStore.default.data(forKey: "customProviders") {
        iCloudProviders = Self.decode([BooruProviderCustom].self, from: iCloudData) ?? []
      }

      let localProviders = Self.decode([BooruProviderCustom].self, from: customProvidersData) ?? []
      let mergedProviders = Array(Set(localProviders + iCloudProviders))

      NSUbiquitousKeyValueStore.default.set(Self.encode(mergedProviders), forKey: "customProviders")

      customProvidersData = Self.encode(mergedProviders) ?? Data()

      loadBookmarksCache()
      loadSearchHistoryCache()
    }
  }

  // MARK: Bookmark Management
  func addBookmark(provider: BooruProvider, tags: [String]) {
    var updatedBookmarks = bookmarks

    updatedBookmarks.append(
      SettingsBookmark(provider: provider, tags: tags.map { $0.lowercased() })
    )

    if let data = Self.encode(updatedBookmarks), data.count < 1_000_000 {  // 1 MB
      bookmarks = updatedBookmarks
    } else {
      debugPrint("SettingsManager.addBookmark: iCloud data limit exceeded")
    }
  }

  func removeBookmark(at offsets: IndexSet) {
    bookmarks.remove(atOffsets: offsets)
  }

  func removeBookmark(withTags tags: [String]) {
    bookmarks.removeAll { $0.tags.contains(where: tags.contains) }
  }

  func removeBookmark(withID id: UUID) {
    bookmarks.removeAll { $0.id == id }
  }

  func exportBookmarks() throws -> Data {
    try JSONEncoder().encode(bookmarks)
  }

  func importBookmarks(from data: Data) throws {
    let importedBookmarks = try JSONDecoder().decode([SettingsBookmark].self, from: data)
    let existingBookmarkIDs = Set(bookmarks.map(\.id))
    let newBookmarks = importedBookmarks.filter { !existingBookmarkIDs.contains($0.id) }

    bookmarks.append(contentsOf: newBookmarks)
  }

  func updateBookmarkFolder(withID id: UUID, folder: UUID?) {
    guard let index = bookmarks.firstIndex(where: { $0.id == id }) else { return }

    bookmarks[index].folder = folder

    Task { @MainActor in
      self.syncToCloud()
    }
  }

  func updateBookmarkLastVisit(withID id: UUID, date: Date = Date()) {
    guard let index = bookmarks.firstIndex(of: bookmarks.first(where: { $0.id == id })!) else {
      return
    }

    bookmarks[index].lastVisit = date

    Task { @MainActor in
      self.syncToCloud()
    }
  }

  func incrementBookmarkVisitCount(withID id: UUID) {
    guard let index = bookmarks.firstIndex(of: bookmarks.first(where: { $0.id == id })!) else {
      return
    }

    bookmarks[index].visitedCount += 1

    Task { @MainActor in
      self.syncToCloud()
    }
  }

  func folderName(forID id: UUID) -> String? {
    folders.first { $0.id == id }?.name
  }

  func renameFolder(_ folder: SettingsFolder, to newName: String) {
    guard let index = folders.firstIndex(where: { $0.id == folder.id }) else { return }

    folders[index].name = newName
  }

  // MARK: Search History Management
  func removeSearchHistoryEntry(at offsets: IndexSet) {
    searchHistory.remove(atOffsets: offsets)
  }

  func removeSearchHistoryEntry(withID id: UUID) {
    searchHistory.removeAll { $0.id == id }
  }

  #if DEBUG
    // https://stackoverflow.com/a/68926484/14452787
    private func randomWord() -> String {
      var word = ""

      for _ in 0..<5 {
        word += String(format: "%c", Int.random(in: 97..<123)) as String
      }

      return word
    }

    func addDummyBookmarks() {
      for _ in 0..<10 {
        let randomTags: [String] = Array(repeating: randomWord(), count: Int.random(in: 1...5))

        addBookmark(provider: .safebooru, tags: randomTags)
      }
    }

    func addDummySearchHistory() {
      for _ in 0..<10 {
        let randomTags: [String] = Array(repeating: randomWord(), count: Int.random(in: 1...5))

        appendToSearchHistory(
          BooruSearchQuery(provider: .safebooru, tags: randomTags)
        )
      }
    }
  #endif

  // MARK: - Deinitialisation
  deinit {
    if let observation = syncObservation {
      NotificationCenter.default.removeObserver(observation)
    }
  }
}