//
//  SPAppCacheManager.swift
//  MoviaBox
//
//  Created by 佳尔 on 2025/4/29.
//

import UIKit
import Kingfisher

class SPAppCacheManager: NSObject {
    
    static let manager = SPAppCacheManager()
    
    private(set) var imageCache: Double = 0
    private(set) var videoCache: Double = 0
    var allCache: Double {
        return imageCache + videoCache
    }
    
    private var group = DispatchGroup()
    
    ///获取全部缓存
    func getAllCache(completer: ((_ value: Double) -> Void)?) {
        
        self.group.enter()
        getImageCache { [weak self] value in
            guard let self = self else { return }
            self.group.leave()
        }
        
        self.group.enter()
        getVideoCache { [weak self] value in
            guard let self = self else { return }
            self.group.leave()
        }
        
        self.group.notify(queue: DispatchQueue.main) { [weak self] in
            guard let self = self else { return }
            completer?(self.imageCache + self.videoCache)
        }
    }
    
    ///清理全部缓存
    func cleanAllCache(completer: (() -> Void)?) {
        self.group.enter()
        cleanImageCache { [weak self] in
            self?.group.leave()
        }
        self.group.enter()
        cleanVideoCache { [weak self] in
            self?.group.leave()
        }
        
        self.group.notify(queue: DispatchQueue.main) { [weak self] in
            guard let self = self else { return }
            completer?()
        }
    }
    
    ///获取图片缓存
    func getImageCache(completer: ((_ value: Double) -> Void)?) {
        ImageCache.default.calculateDiskStorageSize { [weak self] result in
            guard let self = self else { return }
            switch result {
                case .success(let value):
                    self.imageCache = Double(value)
                default:
                    self.imageCache = 0
                    break
            }
            completer?(self.imageCache)
        }
    }
    
    ///获取视频缓存
    func getVideoCache(completer: ((_ value: Double) -> Void)?) {
        self.videoCache = Double(KTVHTTPCache.cacheTotalCacheLength())
        completer?(self.videoCache)
    }
    
    ///清理图片缓存
    func cleanImageCache(completer: (() -> Void)?) {
        DispatchQueue.global().async {
            ImageCache.default.clearDiskCache {
                self.imageCache = 0
                completer?()
            }
        }
    }

    ///清理视频缓存
    func cleanVideoCache(completer: (() -> Void)?) {
        KTVHTTPCache.cacheDeleteAllCaches()
        self.videoCache = 0
        completer?()
    }
    
    
}

extension SPAppCacheManager {
    
    static func cacheToString(cache: Double) -> String {
        let size = cache / 1024 / 1024
        if size > 100 {
            return String(format: "%.0fM", size)
        } else {
            return String(format: "%.2fM", size)
        }
    }
    
}