// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//

#if DEPLOYMENT_RUNTIME_OBJC || os(Linux)
    import Foundation
    import XCTest
#else
    import SwiftFoundation
    import SwiftXCTest
#endif

class TestNSFileManager : XCTestCase {
    
    static var allTests: [(String, (TestNSFileManager) -> () throws -> Void)] {
        return [
            ("test_createDirectory", test_createDirectory ),
            ("test_createFile", test_createFile ),
            ("test_moveFile", test_moveFile),
            ("test_fileSystemRepresentation", test_fileSystemRepresentation),
            ("test_fileAttributes", test_fileAttributes),
            ("test_setFileAttributes", test_setFileAttributes),
            ("test_directoryEnumerator", test_directoryEnumerator),
            ("test_pathEnumerator",test_pathEnumerator),
            ("test_contentsOfDirectoryAtPath", test_contentsOfDirectoryAtPath),
            ("test_subpathsOfDirectoryAtPath", test_subpathsOfDirectoryAtPath),
        ]
    }
    
    func ignoreError(_ block: @noescape () throws -> Void) {
        do { try block() } catch { }
    }
    
    func test_createDirectory() {
        let fm = NSFileManager.defaultManager()
        let path = "/tmp/testdir\(NSUUID().UUIDString)"
        
        ignoreError { try fm.removeItem(atPath: path) }
        
        do {
            try fm.createDirectory(atPath: path, withIntermediateDirectories: false, attributes: nil)
        } catch _ {
            XCTFail()
        }
        
        var isDir = false
        let exists = fm.fileExists(atPath: path, isDirectory: &isDir)
        XCTAssertTrue(exists)
        XCTAssertTrue(isDir)

        do {
            try fm.removeItem(atPath: path)
        } catch {
            XCTFail("Failed to clean up file")
        }
        
    }
    
    func test_createFile() {
        let fm = NSFileManager.defaultManager()
        let path = "/tmp/testfile\(NSUUID().UUIDString)"
        
        ignoreError { try fm.removeItem(atPath: path) }
        
        XCTAssertTrue(fm.createFile(atPath: path, contents: NSData(), attributes: nil))
        
        var isDir = false
        let exists = fm.fileExists(atPath: path, isDirectory: &isDir)
        XCTAssertTrue(exists)
        XCTAssertFalse(isDir)
        
        do {
            try fm.removeItem(atPath: path)
        } catch {
            XCTFail("Failed to clean up file")
        }
    }

    func test_moveFile() {
        let fm = NSFileManager.defaultManager()
        let path = "/tmp/testfile\(NSUUID().UUIDString)"
        let path2 = "/tmp/testfile2\(NSUUID().UUIDString)"

        func cleanup() {
            ignoreError { try fm.removeItem(atPath: path) }
            ignoreError { try fm.removeItem(atPath: path2) }
        }

        cleanup()

        XCTAssertTrue(fm.createFile(atPath: path, contents: NSData(), attributes: nil))
        defer { cleanup() }

        do {
            try fm.moveItem(atPath: path, toPath: path2)
        } catch let error {
            XCTFail("Failed to move file: \(error)")
        }
    }

    func test_fileSystemRepresentation() {
        let str = "☃"
        let result = NSFileManager.defaultManager().fileSystemRepresentation(withPath: str)
        XCTAssertNotNil(result)
        let uintResult = UnsafePointer<UInt8>(result)
        XCTAssertEqual(uintResult[0], 0xE2)
        XCTAssertEqual(uintResult[1], 0x98)
        XCTAssertEqual(uintResult[2], 0x83)
    }
    
    func test_fileAttributes() {
        let fm = NSFileManager.defaultManager()
        let path = "/tmp/test_fileAttributes\(NSUUID().UUIDString)"

        ignoreError { try fm.removeItem(atPath: path) }
        
        XCTAssertTrue(fm.createFile(atPath: path, contents: NSData(), attributes: nil))
        
        do {
            let attrs = try fm.attributesOfItem(atPath: path)
            
            XCTAssertTrue(attrs.count > 0)
            
            let fileSize = attrs[NSFileSize] as? NSNumber
            XCTAssertEqual(fileSize!.int64Value, 0)
            
            let fileModificationDate = attrs[NSFileModificationDate] as? NSDate
            XCTAssertGreaterThan(NSDate().timeIntervalSince1970, fileModificationDate!.timeIntervalSince1970)
            
            let filePosixPermissions = attrs[NSFilePosixPermissions] as? NSNumber
            XCTAssertNotEqual(filePosixPermissions!.int64Value, 0)
            
            let fileReferenceCount = attrs[NSFileReferenceCount] as? NSNumber
            XCTAssertEqual(fileReferenceCount!.int64Value, 1)
            
            let fileSystemNumber = attrs[NSFileSystemNumber] as? NSNumber
            XCTAssertNotEqual(fileSystemNumber!.int64Value, 0)
            
            let fileSystemFileNumber = attrs[NSFileSystemFileNumber] as? NSNumber
            XCTAssertNotEqual(fileSystemFileNumber!.int64Value, 0)
            
            let fileType = attrs[NSFileType] as? String
            XCTAssertEqual(fileType!, NSFileTypeRegular)
            
            let fileOwnerAccountID = attrs[NSFileOwnerAccountID] as? NSNumber
            XCTAssertNotNil(fileOwnerAccountID)
            
        } catch let err {
            XCTFail("\(err)")
        }
        
        do {
            try fm.removeItem(atPath: path)
        } catch {
            XCTFail("Failed to clean up files")
        }
    }
    
    func test_setFileAttributes() {
        let path = "/tmp/test_setFileAttributes\(NSUUID().UUIDString)"
        let fm = NSFileManager.defaultManager()
        
        ignoreError { try fm.removeItem(atPath: path) }
        XCTAssertTrue(fm.createFile(atPath: path, contents: NSData(), attributes: nil))
        
        do {
            try fm.setAttributes([NSFilePosixPermissions:NSNumber(value: Int16(0o0600))], ofItemAtPath: path)
        }
        catch { XCTFail("\(error)") }
        
        //read back the attributes
        do {
            let attributes = try fm.attributesOfItem(atPath: path)
            XCTAssert((attributes[NSFilePosixPermissions] as? NSNumber)?.int16Value == 0o0600)
        }
        catch { XCTFail("\(error)") }

        do {
            try fm.removeItem(atPath: path)
        } catch {
            XCTFail("Failed to clean up files")
        }
    }
    
    func test_pathEnumerator() {
        let fm = NSFileManager.defaultManager()
        let testDirName = "testdir\(NSUUID().UUIDString)"
        let basePath = "/tmp/\(testDirName)"
        let itemPath = "/tmp/\(testDirName)/item"
        let basePath2 = "/tmp/\(testDirName)/path2"
        let itemPath2 = "/tmp/\(testDirName)/path2/item"
        
        ignoreError { try fm.removeItem(atPath: basePath) }
        
        do {
            try fm.createDirectory(atPath: basePath, withIntermediateDirectories: false, attributes: nil)
            try fm.createDirectory(atPath: basePath2, withIntermediateDirectories: false, attributes: nil)

            fm.createFile(atPath: itemPath, contents: NSData(), attributes: nil)
            fm.createFile(atPath: itemPath2, contents: NSData(), attributes: nil)

        } catch _ {
            XCTFail()
        }
        
        if let e = NSFileManager.defaultManager().enumerator(atPath: basePath) {
            let foundItems = NSMutableSet()
            while let item = e.nextObject() as? NSString {
                foundItems.addObject(item)
            }
            XCTAssertEqual(foundItems, NSMutableSet(array: ["item".bridge(),"path2".bridge(),"path2/item".bridge()]))
        } else {
            XCTFail()
        }

    }
    
    func test_directoryEnumerator() {
        let fm = NSFileManager.defaultManager()
        let testDirName = "testdir\(NSUUID().UUIDString)"
        let path = "/tmp/\(testDirName)"
        let itemPath = "/tmp/\(testDirName)/item"
        
        ignoreError { try fm.removeItem(atPath: path) }
        
        do {
            try fm.createDirectory(atPath: path, withIntermediateDirectories: false, attributes: nil)
            fm.createFile(atPath: itemPath, contents: NSData(), attributes: nil)
        } catch _ {
            XCTFail()
        }
        
        if let e = NSFileManager.defaultManager().enumerator(at: NSURL(fileURLWithPath: path), includingPropertiesForKeys: nil, options: [], errorHandler: nil) {
            var foundItems = [String:Int]()
            while let item = e.nextObject() as? NSURL {
                if let p = item.path {
                    foundItems[p] = e.level
                }
            }
            XCTAssertEqual(foundItems[itemPath], 1)
        } else {
            XCTFail()
        }
        
        let subDirPath = "/tmp/\(testDirName)/testdir2"
        let subDirItemPath = "/tmp/\(testDirName)/testdir2/item"
        do {
            try fm.createDirectory(atPath: subDirPath, withIntermediateDirectories: false, attributes: nil)
            fm.createFile(atPath: subDirItemPath, contents: NSData(), attributes: nil)
        } catch _ {
            XCTFail()
        }
        
        if let e = NSFileManager.defaultManager().enumerator(at: NSURL(fileURLWithPath: path), includingPropertiesForKeys: nil, options: [], errorHandler: nil) {
            var foundItems = [String:Int]()
            while let item = e.nextObject() as? NSURL {
                if let p = item.path {
                    foundItems[p] = e.level
                }
            }
            XCTAssertEqual(foundItems[itemPath], 1)
            XCTAssertEqual(foundItems[subDirPath], 1)
            XCTAssertEqual(foundItems[subDirItemPath], 2)
        } else {
            XCTFail()
        }
        
        if let e = NSFileManager.defaultManager().enumerator(at: NSURL(fileURLWithPath: path), includingPropertiesForKeys: nil, options: [.skipsSubdirectoryDescendants], errorHandler: nil) {
            var foundItems = [String:Int]()
            while let item = e.nextObject() as? NSURL {
                if let p = item.path {
                    foundItems[p] = e.level
                }
            }
            XCTAssertEqual(foundItems[itemPath], 1)
            XCTAssertEqual(foundItems[subDirPath], 1)
        } else {
            XCTFail()
        }
        
        if let e = NSFileManager.defaultManager().enumerator(at: NSURL(fileURLWithPath: path), includingPropertiesForKeys: nil, options: [], errorHandler: nil) {
            var foundItems = [String:Int]()
            while let item = e.nextObject() as? NSURL {
                if let p = item.path {
                    foundItems[p] = e.level
                }
            }
            XCTAssertEqual(foundItems[itemPath], 1)
            XCTAssertEqual(foundItems[subDirPath], 1)
        } else {
            XCTFail()
        }
        
        var didGetError = false
        let handler : (NSURL, NSError) -> Bool = { (NSURL, NSError) in
            didGetError = true
            return true
        }
        if let e = NSFileManager.defaultManager().enumerator(at: NSURL(fileURLWithPath: "/nonexistant-path"), includingPropertiesForKeys: nil, options: [], errorHandler: handler) {
            XCTAssertNil(e.nextObject())
        } else {
            XCTFail()
        }
        XCTAssertTrue(didGetError)
        
        do {
            let contents = try NSFileManager.defaultManager().contentsOfDirectory(at: NSURL(fileURLWithPath: path), includingPropertiesForKeys: nil, options: []).map {
                return $0.path!
            }
            XCTAssertEqual(contents.count, 2)
            XCTAssertTrue(contents.contains(itemPath))
            XCTAssertTrue(contents.contains(subDirPath))
        } catch {
            XCTFail()
        }
        
        do {
            try fm.removeItem(atPath: path)
        } catch {
            XCTFail("Failed to clean up files")
        }
    }
    
    func test_contentsOfDirectoryAtPath() {
        let fm = NSFileManager.defaultManager()
        let testDirName = "testdir\(NSUUID().UUIDString)"
        let path = "/tmp/\(testDirName)"
        let itemPath1 = "/tmp/\(testDirName)/item"
        let itemPath2 = "/tmp/\(testDirName)/item2"
        
        ignoreError { try fm.removeItem(atPath: path) }
        
        do {
            try fm.createDirectory(atPath: path, withIntermediateDirectories: false, attributes: nil)
            fm.createFile(atPath: itemPath1, contents: NSData(), attributes: nil)
            fm.createFile(atPath: itemPath2, contents: NSData(), attributes: nil)
        } catch _ {
            XCTFail()
        }
        
        do {
            let entries = try fm.contentsOfDirectory(atPath: path)
            
            XCTAssertEqual(2, entries.count)
            XCTAssertTrue(entries.contains("item"))
            XCTAssertTrue(entries.contains("item2"))
        }
        catch _ {
            XCTFail()
        }
        
        do {
            try fm.contentsOfDirectory(atPath: "")
            
            XCTFail()
        }
        catch _ {
            // Invalid directories should fail.
        }
        
        do {
            try fm.removeItem(atPath: path)
        } catch {
            XCTFail("Failed to clean up files")
        }
    }
    
    func test_subpathsOfDirectoryAtPath() {
        let fm = NSFileManager.defaultManager()
        let path = "/tmp/testdir"
        let path2 = "/tmp/testdir/sub"
        let itemPath1 = "/tmp/testdir/item"
        let itemPath2 = "/tmp/testdir/item2"
        let itemPath3 = "/tmp/testdir/sub/item3"
                
        ignoreError { try fm.removeItem(atPath: path) }
        
        do {
            try fm.createDirectory(atPath: path, withIntermediateDirectories: false, attributes: nil)
            fm.createFile(atPath: itemPath1, contents: NSData(), attributes: nil)
            fm.createFile(atPath: itemPath2, contents: NSData(), attributes: nil)
            
            try fm.createDirectory(atPath: path2, withIntermediateDirectories: false, attributes: nil)
            fm.createFile(atPath: itemPath3, contents: NSData(), attributes: nil)
        } catch _ {
            XCTFail()
        }
        
        do {
            let entries = try fm.subpathsOfDirectory(atPath: path)
            
            XCTAssertEqual(4, entries.count)
            XCTAssertTrue(entries.contains("item"))
            XCTAssertTrue(entries.contains("item2"))
            XCTAssertTrue(entries.contains("sub"))
            XCTAssertTrue(entries.contains("sub/item3"))
        }
        catch _ {
            XCTFail()
        }
        
        do {
            try fm.subpathsOfDirectory(atPath: "")
            
            XCTFail()
        }
        catch _ {
            // Invalid directories should fail.
        }
        
        do {
            try fm.removeItem(atPath: path)
        } catch {
            XCTFail("Failed to clean up files")
        }
    }
}