//
//  StorageServiceTests.swift
//  AutoCatCoreTests
//
//  Created by Selim Mustafaev on 13.07.2024.
//  Copyright © 2024 Selim Mustafaev. All rights reserved.
//

import Testing
import RealmSwift
import Foundation
import Mockable

@testable import AutoCatCore

struct StorageServiceTests {
    
    let existingVehicleNumber = "А123АА761"
    let nonExistingVehicleNumber = "А999АА761"
    let noteText = "Test note text"
    let testLat: Double = 42
    let testLon: Double = 24

    let settingsServiceMock: MockSettingsServiceProtocol
    let storageService: StorageService
    let realmConfig: Realm.Configuration
    
    init() async throws {
        
        var config = Realm.Configuration.defaultConfiguration
        config.inMemoryIdentifier = UUID().uuidString
        self.realmConfig = config
        
        settingsServiceMock = MockSettingsServiceProtocol()
        self.storageService = try await StorageService(settingsService: settingsServiceMock, config: realmConfig)
        
        try addTestVehicle(config: realmConfig)
        
        given(settingsServiceMock)
            .user.willReturn(User())
    }
    
    func addTestVehicle(config: Realm.Configuration) throws {
        
        let vehicle = Vehicle(existingVehicleNumber)
        vehicle.addedDate = 0
        vehicle.updatedDate = 0
        
        let realm = try Realm(configuration: config)
        try realm.write {
            realm.add(vehicle)
        }
    }
    
    func makeRealm() throws -> Realm {
        try Realm(configuration: realmConfig)
    }
    
    @Test("Load existing vehicle")
    func loadExistingVehicle() async throws {
        
        let vehicle = try await storageService.loadVehicle(number: existingVehicleNumber)
        #expect(vehicle.number == existingVehicleNumber)
    }
    
    @Test("Load non-existent vehicle")
    func loadNonExistentVehicle() async throws {
        
        await #expect(throws: StorageError.vehicleNotFound) {
            _ = try await storageService.loadVehicle(number: nonExistingVehicleNumber)
        }
    }
    
    @Test("Update existing vehicle", arguments: DbUpdatePolicy.allCases)
    func updateVehicle(policy: DbUpdatePolicy) async throws {
        
        let vehicle = VehicleDto(number: existingVehicleNumber)
        
        let updated = try await storageService.updateVehicle(dto: vehicle, policy: policy)
        
        #expect(updated == true)
    }
    
    @Test("Update non-existent vehicle", arguments: DbUpdatePolicy.allCases)
    func updateNonExistentVehicle(policy: DbUpdatePolicy) async throws {
        
        let vehicle = VehicleDto(number: nonExistingVehicleNumber)
        
        let updated = try await storageService.updateVehicle(dto: vehicle, policy: policy)
        
        switch policy {
        case .always:
            #expect(updated == true)
        case .ifExists:
            #expect(updated == false)
        }
    }
    
    @Test("Delete vehicle")
    func deleteVehicle() async throws {
        
        try await storageService.deleteVehicle(number: existingVehicleNumber)
        
        let realm = try makeRealm()
        let vehicle = realm.object(ofType: Vehicle.self, forPrimaryKey: existingVehicleNumber)
        
        #expect(vehicle == nil)
    }
    
    @Test("Delete non-existent vehicle")
    func deleteNonExistentVehicle() async throws {
        
        await #expect(throws: StorageError.vehicleNotFound) {
            try await storageService.deleteVehicle(number: nonExistingVehicleNumber)
        }
    }
}