path: root/SoraTests/SettingsManagerSyncTests.swift

import Foundation
import XCTest

// swiftlint:disable type_body_length
final class SettingsManagerSyncTests: XCTestCase {
  func testBookmarkMutationPathReusesEncodedPayload() throws {
    let source = try loadSource(at: "Sora/Data/Settings/SettingsManager.swift")
    let addBookmarkSection = try extractFunction(
      named: "func addBookmark(provider: BooruProvider, tags: [String], folder: UUID? = nil)",
      from: source
    )
    let updateBookmarksSection = try extractFunction(named: "func updateBookmarks(", from: source)
    let bookmarksSetterSection = try extractFunction(named: "var bookmarks: [SettingsBookmark]", from: source)
    let normalizedAddBookmark = strippingCommentsAndStrings(from: addBookmarkSection)
    let normalizedUpdateBookmarks = strippingCommentsAndStrings(from: updateBookmarksSection)
    let normalizedBookmarksSetter = strippingCommentsAndStrings(from: bookmarksSetterSection)

    let addBookmarkInlineEncodeCount = tokenCount(
      matching: #"Self\s*\.\s*encode\s*\(\s*updatedBookmarks\s*\)"#,
      in: normalizedAddBookmark
    )
    let updateBookmarksPreEncodedForwardCount = tokenCount(
      matching: #"syncableData\s*\([\s\S]*?\bencodedData\s*:"#,
      in: normalizedUpdateBookmarks
    )
    let bookmarksSetterPreEncodedForwardCount = tokenCount(
      matching: #"syncableData\s*\([\s\S]*?\bencodedData\s*:"#,
      in: normalizedBookmarksSetter
    )

    // swiftlint:disable:next prefer_nimble
    XCTAssertEqual(
      addBookmarkInlineEncodeCount,
      0,
      "addBookmark should not pre-encode and then trigger another encode downstream."
    )
    // swiftlint:disable:next prefer_nimble
    XCTAssertGreaterThan(
      updateBookmarksPreEncodedForwardCount,
      0,
      "updateBookmarks should forward a pre-encoded payload to syncableData to avoid duplicate encoding."
    )
    // swiftlint:disable:next prefer_nimble
    XCTAssertGreaterThan(
      bookmarksSetterPreEncodedForwardCount,
      0,
      "bookmarks setter should forward a pre-encoded payload to syncableData."
    )
  }

  func testFavoriteMutationPathReusesEncodedPayload() throws {
    let source = try loadSource(at: "Sora/Data/Settings/SettingsManager.swift")
    let addFavoriteSection = try extractFunction(
      named: "func addFavorite(post: BooruPost, provider: BooruProvider, folder: UUID? = nil)",
      from: source
    )
    let updateFavoritesSection = try extractFunction(named: "func updateFavorites(", from: source)
    let favoritesSetterSection = try extractFunction(named: "var favorites: [SettingsFavoritePost]", from: source)
    let normalizedAddFavorite = strippingCommentsAndStrings(from: addFavoriteSection)
    let normalizedUpdateFavorites = strippingCommentsAndStrings(from: updateFavoritesSection)
    let normalizedFavoritesSetter = strippingCommentsAndStrings(from: favoritesSetterSection)

    let addFavoriteInlineEncodeCount = tokenCount(
      matching: #"Self\s*\.\s*encode\s*\(\s*updatedFavorites\s*\)"#,
      in: normalizedAddFavorite
    )
    let updateFavoritesPreEncodedForwardCount = tokenCount(
      matching: #"syncableData\s*\([\s\S]*?\bencodedData\s*:"#,
      in: normalizedUpdateFavorites
    )
    let favoritesSetterPreEncodedForwardCount = tokenCount(
      matching: #"syncableData\s*\([\s\S]*?\bencodedData\s*:"#,
      in: normalizedFavoritesSetter
    )

    // swiftlint:disable:next prefer_nimble
    XCTAssertEqual(
      addFavoriteInlineEncodeCount,
      0,
      "addFavorite should not pre-encode and then trigger another encode downstream."
    )
    // swiftlint:disable:next prefer_nimble
    XCTAssertGreaterThan(
      updateFavoritesPreEncodedForwardCount,
      0,
      "updateFavorites should forward a pre-encoded payload to syncableData to avoid duplicate encoding."
    )
    // swiftlint:disable:next prefer_nimble
    XCTAssertGreaterThan(
      favoritesSetterPreEncodedForwardCount,
      0,
      "favorites setter should forward a pre-encoded payload to syncableData."
    )
  }

  func testBatchedSyncPathGuardsUnchangedPayloadWrites() throws {
    let source = try loadSource(at: "Sora/Data/Settings/SettingsManager.swift")
    let triggerSyncSection = try extractFunction(
      named: "private func triggerSyncIfNeeded(for key: SettingsSyncKey)",
      from: source
    )
    let normalizedSection = strippingCommentsAndStrings(from: triggerSyncSection)

    let cloudWriteCount = tokenCount(
      matching: #"\bNSUbiquitousKeyValueStore\s*\.\s*default\s*\.\s*set\s*\(\s*encoded\s*,\s*forKey\s*:"#,
      in: normalizedSection
    )
    let unchangedGuardCount = tokenCount(
      matching: #"\!\=\s*encoded\b"#,
      in: normalizedSection
    )

    // swiftlint:disable:next prefer_nimble
    XCTAssertGreaterThan(cloudWriteCount, 0, "Expected batched sync path to contain cloud writes.")
    // swiftlint:disable:next prefer_nimble
    XCTAssertGreaterThanOrEqual(
      unchangedGuardCount,
      cloudWriteCount,
      "Every batched iCloud write should be guarded to avoid unchanged payload rewrites."
    )
  }

  private func loadSource(at relativePath: String) throws -> String {
    let currentFile = URL(fileURLWithPath: #filePath)
    let repositoryRoot = currentFile.deletingLastPathComponent().deletingLastPathComponent()
    let fileURL = repositoryRoot.appendingPathComponent(relativePath)

    return try String(contentsOf: fileURL, encoding: .utf8)
  }

  // swiftlint:disable:next cyclomatic_complexity
  private func extractFunction(named signature: String, from source: String) throws -> String {
    guard let signatureRange = source.range(of: signature) else {
      throw NSError(domain: "SettingsManagerSyncTests", code: 1)
    }
    guard let openingBrace = source[signatureRange.upperBound...].firstIndex(of: "{") else {
      throw NSError(domain: "SettingsManagerSyncTests", code: 2)
    }

    let characters = Array(source)
    let startOffset = source.distance(from: source.startIndex, to: signatureRange.lowerBound)
    var currentOffset = source.distance(from: source.startIndex, to: openingBrace)

    var braceDepth = 0
    var inLineComment = false
    var blockCommentDepth = 0
    var inString = false
    var isEscaped = false

    while currentOffset < characters.count {
      let current = characters[currentOffset]
      let next: Character? = currentOffset + 1 < characters.count ? characters[currentOffset + 1] : nil

      if inLineComment {
        if current == "\n" {
          inLineComment = false
        }
        currentOffset += 1
        continue
      }

      if blockCommentDepth > 0 {
        if current == "/", next == "*" {
          blockCommentDepth += 1
          currentOffset += 2
          continue
        }

        if current == "*", next == "/" {
          blockCommentDepth -= 1
          currentOffset += 2
          continue
        }

        currentOffset += 1
        continue
      }

      if inString {
        if isEscaped {
          isEscaped = false
        } else if current == "\\" {
          isEscaped = true
        } else if current == "\"" {
          inString = false
        }

        currentOffset += 1
        continue
      }

      if current == "/", next == "/" {
        inLineComment = true
        currentOffset += 2
        continue
      }

      if current == "/", next == "*" {
        blockCommentDepth = 1
        currentOffset += 2
        continue
      }

      if current == "\"" {
        inString = true
        currentOffset += 1
        continue
      }

      if current == "{" {
        braceDepth += 1
      } else if current == "}" {
        braceDepth -= 1

        if braceDepth == 0 {
          let endIndex = source.index(source.startIndex, offsetBy: currentOffset + 1)
          let startIndex = source.index(source.startIndex, offsetBy: startOffset)

          return String(source[startIndex..<endIndex])
        }
      }

      currentOffset += 1
    }

    throw NSError(domain: "SettingsManagerSyncTests", code: 3)
  }

  // swiftlint:disable:next cyclomatic_complexity
  private func strippingCommentsAndStrings(from source: String) -> String {
    let characters = Array(source)
    var result: [Character] = []
    result.reserveCapacity(characters.count)

    var currentOffset = 0
    var inLineComment = false
    var blockCommentDepth = 0
    var inString = false
    var isEscaped = false

    while currentOffset < characters.count {
      let current = characters[currentOffset]
      let next: Character? = currentOffset + 1 < characters.count ? characters[currentOffset + 1] : nil

      if inLineComment {
        if current == "\n" {
          inLineComment = false
          result.append("\n")
        } else {
          result.append(" ")
        }
        currentOffset += 1
        continue
      }

      if blockCommentDepth > 0 {
        if current == "/", next == "*" {
          blockCommentDepth += 1
          result.append(" ")
          result.append(" ")
          currentOffset += 2
          continue
        }

        if current == "*", next == "/" {
          blockCommentDepth -= 1
          result.append(" ")
          result.append(" ")
          currentOffset += 2
          continue
        }

        result.append(current == "\n" ? "\n" : " ")
        currentOffset += 1
        continue
      }

      if inString {
        if isEscaped {
          isEscaped = false
        } else if current == "\\" {
          isEscaped = true
        } else if current == "\"" {
          inString = false
        }

        result.append(current == "\n" ? "\n" : " ")
        currentOffset += 1
        continue
      }

      if current == "/", next == "/" {
        inLineComment = true
        result.append(" ")
        result.append(" ")
        currentOffset += 2
        continue
      }

      if current == "/", next == "*" {
        blockCommentDepth = 1
        result.append(" ")
        result.append(" ")
        currentOffset += 2
        continue
      }

      if current == "\"" {
        inString = true
        result.append(" ")
        currentOffset += 1
        continue
      }

      result.append(current)
      currentOffset += 1
    }

    return String(result)
  }

  private func tokenCount(matching pattern: String, in source: String) -> Int {
    guard let regex = try? NSRegularExpression(pattern: pattern) else { return 0 }
    let range = NSRange(source.startIndex..<source.endIndex, in: source)

    return regex.numberOfMatches(in: source, range: range)
  }
}
// swiftlint:enable type_body_length