//
//  LocalDataInterface.swift
//  Nextcloud Cookbook iOS Client
//
//  Created by Vincent Meilinger on 07.05.24.
//

import Foundation
import SwiftUI
/*

class LocalDataInterface: CookbookInterface {
    var id: String
        
    init(id: String) {
        self.id = id
    }
    
    enum LocalDataPath {
        case recipeStubs(category: String),
             recipe(id: String),
             image(id: String, size: RecipeImage.RecipeImageSize),
             categories,
             keywords
        
        var path: String {
            switch self {
            case .recipe(let id):
                "recipe_\(id).data"
            case .recipeStubs(let category):
                "recipes_\(category).data"
            case .image(let id, let size):
                if size == .FULL {
                    "image_\(id).data"
                } else {
                    "thumb_\(id).data"
                }
            case .categories:
                "categories.data"
            case .keywords:
                "keywords.data"
            }
        }
    }
}



// MARK: - Local Read Interface

extension LocalDataInterface: ReadInterface {
    func getImage(id: String, size: RecipeImage.RecipeImageSize) async -> UIImage? {
        guard let data: String = await load(path: .image(id: id, size: size)) else {
            return nil
        }
        guard let dataDecoded = Data(base64Encoded: data) else { return nil }
        return UIImage(data: dataDecoded)
    }
    
    func getRecipeStubs() async -> [RecipeStub]? {
        return nil
    }
    
    func getRecipe(id: String) async -> Recipe? {
        return await load(path: LocalDataPath.recipe(id: id))
    }
    
    func getCategories() async -> [Category]? {
        return await load(path: LocalDataPath.categories)
    }
    
    func getRecipeStubsForCategory(named categoryName: String) async -> [RecipeStub]? {
        return await load(path: .recipeStubs(category: categoryName))
    }
    
    func getTags() async -> [RecipeKeyword]? {
        return await load(path: .keywords)
    }
    
    func getRecipesTagged(keyword: String) async -> [RecipeStub]? {
        return nil
    }
    
}



// MARK: - Local Write Interface

extension LocalDataInterface: WriteInterface {
    
    func postImage(id: String, image: UIImage, size: RecipeImage.RecipeImageSize) async -> ((any UserAlert)?) {
        if let data = image.pngData() {
            await save(
                data,
                path: LocalDataPath.image(id: id, size: size)
            )
        }
        return nil
    }
    
    func postRecipe(recipe: Recipe) async -> ((any UserAlert)?) {
        await save(recipe, path: LocalDataPath.recipe(id: recipe.id))
        return nil
    }
    
    func updateRecipe(recipe: Recipe) async -> ((any UserAlert)?) {
        return await postRecipe(recipe: recipe)
    }
    
    func deleteRecipe(id: String) async -> ((any UserAlert)?) {
        await delete(path: .recipe(id: id))
        return nil
    }
    
    func renameCategory(named categoryName: String, newName: String) async -> ((any UserAlert)?) {
        guard let stubs: [RecipeStub] = await load(path: .recipeStubs(category: categoryName)) else {
            return PersistenceAlert.LOAD_FAILED
        }
        await save(stubs, path: .recipeStubs(category: newName))
        await delete(path: .recipeStubs(category: categoryName))
        return nil
    }
    
}



// MARK: - Local Data Interface Utils

extension LocalDataInterface {
    
    func load<T: Codable>(path ldPath: LocalDataPath) async -> T? {
        do {
            return try await DataStore.shared.load(fromPath: ldPath.path)
        } catch (let error) {
            print(error)
            return nil
        }
    }
    
    func save<T: Codable>(_ object: T, path ldPath: LocalDataPath) async {
        await DataStore.shared.save(data: object, toPath: ldPath.path)
    }
    
    func delete(path ldPath: LocalDataPath) async {
        DataStore.shared.delete(path: ldPath.path)
    }
    
}
*/