import Foundation
import Testing
import CryptoKit
@testable import LocalData

@Suite struct EncryptionLogicTests {
    private let encryption = EncryptionHelper(keychain: MockKeychainHelper())
    private let payload = Data("secret".utf8)
    private let keyName = "logic.test.key"

    @Test func pbkdf2WithSingleIteration() async throws {
        let policy: SecurityPolicy.EncryptionPolicy = .aes256(
            keyDerivation: .pbkdf2(iterations: 1)
        )
        
        let encrypted = try await encryption.encrypt(payload, keyName: keyName, policy: policy)
        let decrypted = try await encryption.decrypt(encrypted, keyName: keyName, policy: policy)
        #expect(decrypted == payload)
    }

    @Test func rawDataProviderIntegration() async throws {
        struct RawProvider: KeyMaterialProviding {
            let data: Data
            func keyMaterial(for keyName: String) async throws -> Data { data }
        }
        
        let rawKey = Data(repeating: 1, count: 32)
        let source = KeyMaterialSource(id: "raw.provider")
        await encryption.registerKeyMaterialProvider(RawProvider(data: rawKey), for: source)
        
        let policy = SecurityPolicy.EncryptionPolicy.external(source: source)
        
        let encrypted = try await encryption.encrypt(payload, keyName: keyName, policy: policy)
        let decrypted = try await encryption.decrypt(encrypted, keyName: keyName, policy: policy)
        #expect(decrypted == payload)
    }

    @Test func failedProviderThrows() async {
        struct FailingProvider: KeyMaterialProviding {
            func keyMaterial(for keyName: String) async throws -> Data {
                throw StorageError.securityApplicationFailed
            }
        }
        
        let source = KeyMaterialSource(id: "fail.provider")
        await encryption.registerKeyMaterialProvider(FailingProvider(), for: source)
        
        await #expect(throws: StorageError.securityApplicationFailed) {
            try await encryption.encrypt(payload, keyName: keyName, policy: .external(source: source))
        }
    }
}

@Suite struct AccessControlLogicTests {
    
    @Test func secAccessControlCreation() {
        for control in KeychainAccessControl.allCases {
            let result = control.accessControl(accessibility: .afterFirstUnlock)
            #expect(result != nil)
        }
    }
}