//
//  ViewController.swift
//  Bug
//
//  Created by Damian Malarczyk on 26.02.2016.
//

import Foundation

class ViewController: OperationDelegate {

    let queue = OperationQueue()
    
    struct DataWrapper {
        var data:[Info]?
    }
    
    var rawData:[Info]?
    var source:DataWrapper?
    static let documentsPath =  NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]
    var operation:Operation? = Operation(withPath: ViewController.documentsPath + "/data")
    
    func viewDidLoad() {
        operation?.delegate = self
        queue.addOperation(operation!)
        noOperation()
    }

    
    func noOperation(){
        let runtimeData = NSMutableArray()
        
        //dummy data
        for _ in 0...10 {
            let info = Info()
            
            for _ in 0...10 {
                info.source?.append(Info.BaseInfo(name: "some name"))
            }
            runtimeData.add(info)
        }
        
        // another issue I guess, here I have warning saying that cast from NSMutableArray to [Info] always fails while it doesn't
        if let dataArray = (runtimeData as [AnyObject]) as? [Info] {
            
            //@ leak in both cases, DataWrapper doesnt have impact on that 
            
            self.source = DataWrapper(data:dataArray)
            //self.rawData = dataArray
            
            //let source = DataWrapper(data: dataArray)

        }
    }
    
    func finishedWithData(_ data: NSArray) {
        if let dataArray = data as? [Info] {
            let testLeak = true
            
            if testLeak {
                //memory leak occurs
                self.source = DataWrapper(data: dataArray)
                
            }else {
                //no leak
                let source = DataWrapper(data: dataArray)
            }
        }
        
        operation?.delegate = nil
        operation = nil
    }

}

protocol OperationDelegate {
    func finishedWithData(_ data:NSArray)
}

class Operation:Foundation.Operation {
    
    var path:String
    var delegate:OperationDelegate?
    
    init(withPath path:String){
        self.path = path
        
    }
    
    override func main() {
        let runtimeData = NSMutableArray()
        
        //dummy data
        for _ in 0...10 {
            let info = Info()
            
            for _ in 0...10 {
                info.source?.append(Info.BaseInfo(name: "some name"))
            }
            runtimeData.add(info)
        }
        
        // two cases - data is encoded from file and just normal data
        let encodeDataToFile = false
        
        if encodeDataToFile {
            saveData(runtimeData)
            
            let localData = readData()
            
            if let local = localData {
                delegate?.finishedWithData(local)
                
            }

        }else {
            delegate?.finishedWithData(runtimeData)

        }

    }
    
    deinit {
        print("no reference cycle")
    }
    func saveData(_ data:NSArray){
        
        let mutableData = NSMutableData()
        let archiver = NSKeyedArchiver(forWritingWith: mutableData)
        data.encode(with: archiver)
        archiver.finishEncoding()
        
        try? mutableData.write(toFile: path, options: .atomic)
        
    }
    
    func readData( )->NSArray? {
        let data = NSData.init(contentsOfFile: path)
        if let savedData = data {
            let unarchiver = NSKeyedUnarchiver(forReadingWith: savedData as Data)
            return NSArray(coder: unarchiver)
        }
        return nil
    }
}
class Info:NSCoder {
    static let SOURCE_KEY = "source_key"

    var source:[BaseInfo]?
    
    override init(){
        super.init()
        source = [BaseInfo]()
    }
    
    required  init?(coder aDecoder: NSCoder) {
        source = aDecoder.decodeObject(forKey: Info.SOURCE_KEY) as? [BaseInfo]
    }
    
    func encodeWithCoder(aCoder: NSCoder) {
        aCoder.encode(source, forKey: Info.SOURCE_KEY)
    }

    
    
    class BaseInfo:NSCoder {
        static let NAME_KEY = "name_key"
        
        var name:String

        init(name:String){
            self.name = name
        }
        
        func encodeWithCoder(aCoder: NSCoder) {
            aCoder.encode(name, forKey: BaseInfo.NAME_KEY)
        }
        required  init?(coder aDecoder: NSCoder) {
            name = aDecoder.decodeObject(forKey: BaseInfo.NAME_KEY) as! String
        }
        
    }
}

autoreleasepool {
  ViewController().viewDidLoad()
}

 self.rawData = runtimeData