MEImageManager.swift

MEImageManager.swift

//
//  MEApplicationSettings.swift
//  MagicEyes
//
//  Created by Logan Wright on 12/26/14.
//  Copyright (c) 2014 Intrepid Pursuits, LLC. All rights reserved.
//

import UIKit

private let imageFolderDirectoryName = "MagicEyesImageDirectory"

class MEImageManager: NSObject {
    
    // MARK: Singleton
    
    class func sharedManager() -> MEImageManager {
        struct Singleton {
            static let instance = MEImageManager()
        }
        return Singleton.instance
    }
    
    // MARK: System Manager Pointers
    
    private lazy var standardUserDefaults = NSUserDefaults.standardUserDefaults()
    private lazy var defaultFileManager = NSFileManager.defaultManager()
    
    // MARK: Image Directory
    
    private lazy var imageFolderDirectoryPath: String = {
        let pathsArray = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)
        if let documentsDirectoryPath = pathsArray.first as? String {
            let imageFolderDirectoryPath = documentsDirectoryPath.stringByAppendingPathComponent(imageFolderDirectoryName)
            self.createImageDirectoryIfNecessaryForFolderPath(imageFolderDirectoryPath)
            return imageFolderDirectoryPath
        } else {
            fatalError("Unable to create documents directory!")
        }
    }()
    
    private func createImageDirectoryIfNecessaryForFolderPath(imageFolderPath: String) {
        if !defaultFileManager.fileExistsAtPath(imageFolderPath) {
            var createDirectoryError: NSError?
            defaultFileManager.createDirectoryAtPath(imageFolderPath, withIntermediateDirectories: false, attributes: nil, error: &createDirectoryError)
            if createDirectoryError != nil {
                fatalError("Error creating image directory: \(createDirectoryError)")
            }
        }
    }
    
    private func createImageDirectoryIfNecessary(imageFolderPath: String) {
        if !defaultFileManager.fileExistsAtPath(imageFolderPath) {
            var createDirectoryError: NSError?
            defaultFileManager.createDirectoryAtPath(imageFolderPath, withIntermediateDirectories: false, attributes: nil, error: &createDirectoryError)
            if createDirectoryError != nil {
                fatalError("Error creating image directory: \(createDirectoryError)")
            }
        }
    }
    
    // MARK: Image Writing
    
    func writeImageToFile(image: UIImage) -> Bool {
        let uniqueFileName = NSUUID().UUIDString
        let success = self.writeImageToFile(image, withFileName: uniqueFileName)
        return success
    }
    
    func writeImageToFile(image: UIImage, withFileName fileName: String) -> Bool {
        let directoryPath = self.imageFolderDirectoryPath
        let filePath = directoryPath.stringByAppendingPathComponent(fileName)
        let imageData = UIImageJPEGRepresentation(image, 1.0)
        let imageWriteSuccess = imageData.writeToFile(filePath, atomically: true)
        return imageWriteSuccess
    }
    
    func writeImageToFile(image: UIImage, inBackgroundWithCompletion completion: ((fileName: String, success: Bool) -> Void)?) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), { () -> Void in
            let uniqueFileName = NSUUID().UUIDString
            let success = self.writeImageToFile(image, withFileName: uniqueFileName)
            if let comp = completion {
                dispatch_async(dispatch_get_main_queue(), { () -> Void in
                    comp(fileName: uniqueFileName, success: success)
                })
            }
        })
    }
    
    // MARK: Image Deleting
    
    func deleteImageWithFileName(fileName: String) -> NSError? {
        let completePath = imageFolderDirectoryPath.stringByAppendingPathComponent(fileName)
        var deleteError: NSError?
        defaultFileManager.removeItemAtPath(completePath, error: &deleteError)
        if deleteError != nil {
            println("Error deleting file: \(fileName) error: \(deleteError)")
        }
        return deleteError
    }
    
    // MARK: Image Getting
    
    lazy var retrievedImageCache = NSCache()
    
    var allImageFileNames: [String]? {
        get {
            var error: NSError?
            let allFileNames = defaultFileManager.subpathsOfDirectoryAtPath(imageFolderDirectoryPath, error: &error) as? [String]
            if error != nil {
                println("Error retriving image file names! \(error)")
            }
            return allFileNames
        }
    }
    
    func imageWithFileName(fileName: String) -> UIImage? {
        if let cachedImg = retrievedImageCache.objectForKey(fileName) as? UIImage {
            return cachedImg
        } else {
            let imageDirectoryPath = imageFolderDirectoryPath
            let completeImagePath = imageDirectoryPath.stringByAppendingPathComponent(fileName)
            if defaultFileManager.fileExistsAtPath(completeImagePath) {
                if let img = UIImage(contentsOfFile: completeImagePath) {
                    retrievedImageCache.setObject(img, forKey: fileName)
                    return img
                } else {
                    return nil
                }
            } else {
                return nil
            }
        }
    }
    
}