import Foundation
import Testing
@testable import LocalData

@Suite struct AppGroupTests {
    private let userDefaultsHelper: UserDefaultsHelper
    private let fileStorageHelper: FileStorageHelper
    
    init() {
        let suiteName = "AppGroupTests-\(UUID().uuidString)"
        userDefaultsHelper = UserDefaultsHelper(defaults: UserDefaults(suiteName: suiteName)!)
        
        let testBaseURL = FileManager.default.temporaryDirectory.appending(path: "AppGroupTests-\(UUID().uuidString)")
        fileStorageHelper = FileStorageHelper(configuration: FileStorageConfiguration(baseURL: testBaseURL))
    }
    
    // Note: These tests might fail to find real containers in a unit test environment,
    // but they will exercise the routing logic.
    
    @Test func userDefaultsAppGroupRoundTrip() async throws {
        let identifier = "group.com.test.localdata"
        let key = "test.appgroup.key"
        let data = Data("appgroup-value".utf8)
        
        // This usually works in simulators even without real entitlements
        try await userDefaultsHelper.set(data, forKey: key, appGroupIdentifier: identifier)
        let retrieved = try await userDefaultsHelper.get(forKey: key, appGroupIdentifier: identifier)
        #expect(retrieved == data)
        
        let exists = try await userDefaultsHelper.exists(forKey: key, appGroupIdentifier: identifier)
        #expect(exists == true)
        
        let allKeys = try await userDefaultsHelper.allKeys(appGroupIdentifier: identifier)
        #expect(allKeys.contains(key))
        
        try await userDefaultsHelper.remove(forKey: key, appGroupIdentifier: identifier)
    }
    
    @Test func fileStorageAppGroupError() async throws {
        let identifier = "invalid.group.id"
        let data = Data("data".utf8)
        
        // Simulators often return a URL even for invalid group IDs.
        // On real devices/authorized environments, it returns nil if not matched.
        if FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: identifier) == nil {
            await #expect(throws: StorageError.invalidAppGroupIdentifier(identifier)) {
                try await fileStorageHelper.write(
                    data,
                    to: .documents,
                    fileName: "test.txt",
                    appGroupIdentifier: identifier
                )
            }
        }
    }

    @Test func fileStorageAppGroupRoundTrip() async throws {
        // In simulator, this usually returns a placeholder path
        let identifier = "group.com.test.localdata"
        let fileName = "appgroup_file.txt"
        let data = Data("appgroup-file-content".utf8)
        
        // Only run if the simulator/environment gives us a container
        if let _ = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: identifier) {
            try await fileStorageHelper.write(data, to: .documents, fileName: fileName, appGroupIdentifier: identifier)
            
            let exists = await fileStorageHelper.exists(in: .documents, fileName: fileName, appGroupIdentifier: identifier)
            #expect(exists == true)
            
            let retrieved = try await fileStorageHelper.read(from: .documents, fileName: fileName, appGroupIdentifier: identifier)
            #expect(retrieved == data)
            
            let list = try await fileStorageHelper.list(in: .documents, appGroupIdentifier: identifier)
            #expect(list.contains(fileName))
            
            let size = try await fileStorageHelper.size(of: .documents, fileName: fileName, appGroupIdentifier: identifier)
            #expect(size == Int64(data.count))
            
            try await fileStorageHelper.delete(from: .documents, fileName: fileName, appGroupIdentifier: identifier)
            
            let afterDelete = await fileStorageHelper.exists(in: .documents, fileName: fileName, appGroupIdentifier: identifier)
            #expect(afterDelete == false)
        }
    }
}