//
//  SwiftDataStorageService.swift
//  AutoCatCore
//
//  Created by Selim Mustafaev on 11.06.2025.
//  Copyright © 2025 Selim Mustafaev. All rights reserved.
//

import Foundation
import SwiftData

@MainActor
public final class SwiftDataStorageService: StorageServiceProtocol {
    
    let settingsService: SettingsServiceProtocol
    let container: ModelContainer
    let context: ModelContext
    
    public init(settingsService: SettingsServiceProtocol, isTest: Bool = false) throws {
        
        self.settingsService = settingsService
        
        self.container = try ModelContainer(
            for: SDVehicle.self, SDVehicleNote.self, SDAudioRecord.self,
            configurations: .init(isStoredInMemoryOnly: isTest)
        )
        
        self.context = container.mainContext
    }
    
    public var dbFileURL: URL? {
        
        // TODO: Set specific URL in ModelConfiguration
        get async { nil }
    }
    
    public func deleteAll() async throws {
        
        container.deleteAllData()
    }
    
    @discardableResult
    public func updateVehicle(dto: VehicleDto, policy: DbUpdatePolicy) async throws -> Bool {
        
        let shouldUpdate = switch policy {
        case .always:
            true
        case .ifExists:
            try vehicleExists(number: dto.number)
        }
        
        guard shouldUpdate else {
            return false
        }
        
        context.insert(SDVehicle(dto: dto))
        try context.save()
        
        return true
    }
    
    public func loadVehicle(number: String) async throws -> VehicleDto {
        
        if let vehicle = try fetchVehicle(number: number) {
            return vehicle.dto
        } else {
            throw StorageError.vehicleNotFound
        }
    }
    
    public func loadVehicles() async -> [VehicleDto] {
        
        do {
            return try context.fetch(
                FetchDescriptor<SDVehicle>(
                    sortBy: [SortDescriptor(\.updatedDate, order: .reverse)]
                )
            )
            .map(\.shallowDto)
        } catch {
            return []
        }
    }
    
    public func deleteVehicle(number: String) async throws {
        guard let vehicle = try? fetchVehicle(number: number) else {
            throw StorageError.vehicleNotFound
        }
        
        context.delete(vehicle)
        try context.save()
    }
}