//
//  SwiftDataStorageServiceTests.swift
//  AutoCatCoreTests
//
//  Created by Selim Mustafaev on 13.06.2025.
//  Copyright © 2025 Selim Mustafaev. All rights reserved.
//

import Testing
import Mockable
import SwiftData
import Foundation

@testable import AutoCatCore

@MainActor
struct SwiftDataStorageServiceTests {
    
    let settingsServiceMock = MockSettingsServiceProtocol()
    let storageService: SwiftDataStorageService
    
    let noteText = "Test note text"
    let testLat: Double = 42
    let testLon: Double = 24
    
    init() async throws {
        storageService = try .init(settingsService: settingsServiceMock, isTest: true)
        
        var vehicle: VehicleDto = .normal
        vehicle.addedDate = 0
        vehicle.updatedDate = 0
        try await storageService.updateVehicle(dto: vehicle, policy: .always)
        
        given(settingsServiceMock)
            .user.willReturn(User())
    }

    @Test("Load existing vehicle")
    func loadExistingVehicle() async throws {
        
        let vehicle = try await storageService.loadVehicle(number: VehicleDto.validNumber)
        #expect(vehicle.number == VehicleDto.validNumber)
    }
    
    @Test("Load non-existent vehicle")
    func loadNonExistentVehicle() async throws {
        
        await #expect(throws: StorageError.vehicleNotFound) {
            _ = try await storageService.loadVehicle(number: "")
        }
    }
    
    @Test("Update existing vehicle", arguments: DbUpdatePolicy.allCases)
    func updateVehicle(policy: DbUpdatePolicy) async throws {
        
        var vehicle: VehicleDto = .normal
        vehicle.updatedDate = 123
        
        let updated = try await storageService.updateVehicle(dto: vehicle, policy: policy)
        let vehicles = await storageService.loadVehicles()
        
        #expect(updated == true)
        #expect(vehicles.count == 1)
        #expect(vehicles.first?.updatedDate == 123)
    }
    
    @Test("Update non-existent vehicle", arguments: DbUpdatePolicy.allCases)
    func updateNonExistentVehicle(policy: DbUpdatePolicy) async throws {
        
        let updated = try await storageService.updateVehicle(dto: .normal2, policy: policy)
        let vehicles = await storageService.loadVehicles()
        
        switch policy {
        case .always:
            #expect(updated == true)
            #expect(vehicles.count == 2)
        case .ifExists:
            #expect(updated == false)
            #expect(vehicles.count == 1)
        }
    }
    
    @Test("Delete vehicle")
    func deleteVehicle() async throws {
        
        try await storageService.deleteVehicle(number: VehicleDto.validNumber)
        
        await #expect(throws: StorageError.vehicleNotFound) {
            _ = try await storageService.loadVehicle(number: VehicleDto.validNumber)
        }
    }
    
    @Test("Delete non-existent vehicle")
    func deleteNonExistentVehicle() async throws {
        
        await #expect(throws: StorageError.vehicleNotFound) {
            try await storageService.deleteVehicle(number: "")
        }
    }
}