// 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
//

class TestAffineTransform : XCTestCase {
    private let accuracyThreshold = 0.001

    static var allTests: [(String, (TestAffineTransform) -> () throws -> Void)] {
        return [
            ("test_BasicConstruction", test_BasicConstruction),
            ("test_IdentityTransformation", test_IdentityTransformation),
            ("test_Scale", test_Scale),
            ("test_Scaling", test_Scaling),
            ("test_TranslationScaling", test_TranslationScaling),
            ("test_ScalingTranslation", test_ScalingTranslation),
            ("test_Rotation_Degrees", test_Rotation_Degrees),
            ("test_Rotation_Radians", test_Rotation_Radians),
            ("test_Inversion", test_Inversion),
            ("test_IdentityTransformation", test_IdentityTransformation),
            ("test_Translation", test_Translation),
            ("test_TranslationComposed", test_TranslationComposed),
            ("test_AppendTransform", test_AppendTransform),
            ("test_PrependTransform", test_PrependTransform),
            ("test_TransformComposition", test_TransformComposition),
            ("test_hashing", test_hashing),
            ("test_rotation_compose", test_rotation_compose),
            ("test_translation_and_rotation", test_translation_and_rotation),
            ("test_Equal", test_Equal),
            ("test_NSCoding", test_NSCoding),
        ]
    }
    
    func checkPointTransformation(_ transform: NSAffineTransform, point: NSPoint, expectedPoint: NSPoint, _ message: String = "", file: StaticString = #file, line: UInt = #line) {
        let newPoint = transform.transform(point)
        XCTAssertEqual(Double(newPoint.x), Double(expectedPoint.x), accuracy: accuracyThreshold,
                       "x (expected: \(expectedPoint.x), was: \(newPoint.x)): \(message)", file: file, line: line)
        XCTAssertEqual(Double(newPoint.y), Double(expectedPoint.y), accuracy: accuracyThreshold,
                       "y (expected: \(expectedPoint.y), was: \(newPoint.y)): \(message)", file: file, line: line)
    }
    
    func checkSizeTransformation(_ transform: NSAffineTransform, size: NSSize, expectedSize: NSSize, _ message: String = "", file: StaticString = #file, line: UInt = #line) {
        let newSize = transform.transform(size)
        XCTAssertEqual(Double(newSize.width), Double(expectedSize.width), accuracy: accuracyThreshold,
                       "width (expected: \(expectedSize.width), was: \(newSize.width)): \(message)", file: file, line: line)
        XCTAssertEqual(Double(newSize.height), Double(expectedSize.height), accuracy: accuracyThreshold,
                       "height (expected: \(expectedSize.height), was: \(newSize.height)): \(message)", file: file, line: line)
    }
    
    func checkRectTransformation(_ transform: NSAffineTransform, rect: NSRect, expectedRect: NSRect, _ message: String = "", file: StaticString = #file, line: UInt = #line) {
        let newRect = transform.transformRect(rect)
        
        checkPointTransformation(transform, point: newRect.origin, expectedPoint: expectedRect.origin,
                                 "origin (expected: \(expectedRect.origin), was: \(newRect.origin)): \(message)", file: file, line: line)
        checkSizeTransformation(transform, size: newRect.size, expectedSize: expectedRect.size,
                                "size (expected: \(expectedRect.size), was: \(newRect.size)): \(message)", file: file, line: line)
    }

    func test_BasicConstruction() {
        let identityTransform = NSAffineTransform()
        let transformStruct = identityTransform.transformStruct

        // The diagonal entries (1,1) and (2,2) of the identity matrix are ones. The other entries are zeros.
        // TODO: These should use DBL_MAX but it's not available as part of Glibc on Linux
        XCTAssertEqual(Double(transformStruct.m11), Double(1), accuracy: accuracyThreshold)
        XCTAssertEqual(Double(transformStruct.m22), Double(1), accuracy: accuracyThreshold)

        XCTAssertEqual(Double(transformStruct.m12), Double(0), accuracy: accuracyThreshold)
        XCTAssertEqual(Double(transformStruct.m21), Double(0), accuracy: accuracyThreshold)
        XCTAssertEqual(Double(transformStruct.tX), Double(0), accuracy: accuracyThreshold)
        XCTAssertEqual(Double(transformStruct.tY), Double(0), accuracy: accuracyThreshold)
    }

    func test_IdentityTransformation() {
        let identityTransform = NSAffineTransform()

        func checkIdentityPointTransformation(_ point: NSPoint) {
            checkPointTransformation(identityTransform, point: point, expectedPoint: point)
        }
        
        checkIdentityPointTransformation(NSPoint.zero)
        checkIdentityPointTransformation(NSPoint(x: 24.5, y: 10.0))
        checkIdentityPointTransformation(NSPoint(x: -7.5, y: 2.0))

        func checkIdentitySizeTransformation(_ size: NSSize) {
            checkSizeTransformation(identityTransform, size: size, expectedSize: size)
        }

        checkIdentitySizeTransformation(NSSize.zero)
        checkIdentitySizeTransformation(NSSize(width: 13.0, height: 12.5))
        checkIdentitySizeTransformation(NSSize(width: 100.0, height: -100.0))
    }
    
    func test_Translation() {
        let point = NSPoint.zero

        let noop = NSAffineTransform()
        noop.translateX(by: CGFloat(), yBy: CGFloat())
        checkPointTransformation(noop, point: point, expectedPoint: point)
        
        let translateH = NSAffineTransform()
        translateH.translateX(by: CGFloat(10.0), yBy: CGFloat())
        checkPointTransformation(translateH, point: point, expectedPoint: NSPoint(x: 10.0, y: 0.0))
        
        let translateV = NSAffineTransform()
        translateV.translateX(by: CGFloat(), yBy: CGFloat(20.0))
        checkPointTransformation(translateV, point: point, expectedPoint: NSPoint(x: 0.0, y: 20.0))
        
        let translate = NSAffineTransform()
        translate.translateX(by: CGFloat(-30.0), yBy: CGFloat(40.0))
        checkPointTransformation(translate, point: point, expectedPoint: NSPoint(x: -30.0, y: 40.0))
    }
    
    func test_Scale() {
        let size = NSSize(width: 10.0, height: 10.0)
        
        let noop = NSAffineTransform()
        noop.scale(by: CGFloat(1.0))
        checkSizeTransformation(noop, size: size, expectedSize: size)
        
        let shrink = NSAffineTransform()
        shrink.scale(by: CGFloat(0.5))
        checkSizeTransformation(shrink, size: size, expectedSize: NSSize(width: 5.0, height: 5.0))
        
        let grow = NSAffineTransform()
        grow.scale(by: CGFloat(3.0))
        checkSizeTransformation(grow, size: size, expectedSize: NSSize(width: 30.0, height: 30.0))
        
        let stretch = NSAffineTransform()
        stretch.scaleX(by: CGFloat(2.0), yBy: CGFloat(0.5))
        checkSizeTransformation(stretch, size: size, expectedSize: NSSize(width: 20.0, height: 5.0))
    }
    
    func test_Rotation_Degrees() {
        let point = NSPoint(x: 10.0, y: 10.0)

        let noop = NSAffineTransform()
        noop.rotate(byDegrees: CGFloat())
        checkPointTransformation(noop, point: point, expectedPoint: point)
        
        let tenEighty = NSAffineTransform()
        tenEighty.rotate(byDegrees: CGFloat(1080.0))
        checkPointTransformation(tenEighty, point: point, expectedPoint: point)
        
        let rotateCounterClockwise = NSAffineTransform()
        rotateCounterClockwise.rotate(byDegrees: CGFloat(90.0))
        checkPointTransformation(rotateCounterClockwise, point: point, expectedPoint: NSPoint(x: -10.0, y: 10.0))
        
        let rotateClockwise = NSAffineTransform()
        rotateClockwise.rotate(byDegrees: CGFloat(-90.0))
        checkPointTransformation(rotateClockwise, point: point, expectedPoint: NSPoint(x: 10.0, y: -10.0))
        
        let reflectAboutOrigin = NSAffineTransform()
        reflectAboutOrigin.rotate(byDegrees: CGFloat(180.0))
        checkPointTransformation(reflectAboutOrigin, point: point, expectedPoint: NSPoint(x: -10.0, y: -10.0))
    }
    
    func test_Rotation_Radians() {
        let point = NSPoint(x: 10.0, y: 10.0)

        let noop = NSAffineTransform()
        noop.rotate(byRadians: CGFloat())
        checkPointTransformation(noop, point: point, expectedPoint: point)
        
        let tenEighty = NSAffineTransform()
        tenEighty.rotate(byRadians: 6 * .pi)
        checkPointTransformation(tenEighty, point: point, expectedPoint: point)
        
        let rotateCounterClockwise = NSAffineTransform()
        rotateCounterClockwise.rotate(byRadians: .pi / 2)
        checkPointTransformation(rotateCounterClockwise, point: point, expectedPoint: NSPoint(x: -10.0, y: 10.0))
        
        let rotateClockwise = NSAffineTransform()
        rotateClockwise.rotate(byRadians: -.pi / 2)
        checkPointTransformation(rotateClockwise, point: point, expectedPoint: NSPoint(x: 10.0, y: -10.0))
        
        let reflectAboutOrigin = NSAffineTransform()
        reflectAboutOrigin.rotate(byRadians: .pi)
        checkPointTransformation(reflectAboutOrigin, point: point, expectedPoint: NSPoint(x: -10.0, y: -10.0))
    }
    
    func test_Inversion() {
        let point = NSPoint(x: 10.0, y: 10.0)

        var translate = AffineTransform()
        translate.translate(x: CGFloat(-30.0), y: CGFloat(40.0))
        
        var rotate = AffineTransform()
        translate.rotate(byDegrees: CGFloat(30.0))
        
        var scale = AffineTransform()
        scale.scale(CGFloat(2.0))
        
        let identityTransform = NSAffineTransform()
        
        // append transformations
        identityTransform.append(translate)
        identityTransform.append(rotate)
        identityTransform.append(scale)
        
        // invert transformations
        scale.invert()
        rotate.invert()
        translate.invert()
        
        // append inverse transformations in reverse order
        identityTransform.append(scale)
        identityTransform.append(rotate)
        identityTransform.append(translate)
        
        checkPointTransformation(identityTransform, point: point, expectedPoint: point)
    }

    func test_TranslationComposed() {
        let xyPlus5 = NSAffineTransform()
        xyPlus5.translateX(by: CGFloat(2.0), yBy: CGFloat(3.0))
        xyPlus5.translateX(by: CGFloat(3.0), yBy: CGFloat(2.0))

        checkPointTransformation(xyPlus5, point: NSPoint(x: -2.0, y: -3.0),
                                  expectedPoint: NSPoint(x: 3.0, y: 2.0))
    }

    func test_Scaling() {
        let xyTimes5 = NSAffineTransform()
        xyTimes5.scale(by: CGFloat(5.0))

        checkPointTransformation(xyTimes5, point: NSPoint(x: -2.0, y: 3.0),
                                   expectedPoint: NSPoint(x: -10.0, y: 15.0))

        let xTimes2YTimes3 = NSAffineTransform()
        xTimes2YTimes3.scaleX(by: CGFloat(2.0), yBy: CGFloat(-3.0))

        checkPointTransformation(xTimes2YTimes3, point: NSPoint(x: -1.0, y: 3.5),
                                         expectedPoint: NSPoint(x: -2.0, y: -10.5))
    }

    func test_TranslationScaling() {
        let xPlus2XYTimes5 = NSAffineTransform()
        xPlus2XYTimes5.translateX(by: CGFloat(2.0), yBy: CGFloat())
        xPlus2XYTimes5.scaleX(by: CGFloat(5.0), yBy: CGFloat(-5.0))

        checkPointTransformation(xPlus2XYTimes5, point: NSPoint(x: 1.0, y: 2.0),
                                         expectedPoint: NSPoint(x: 7.0, y: -10.0))
    }

    func test_ScalingTranslation() {
        let xyTimes5XPlus3 = NSAffineTransform()
        xyTimes5XPlus3.scale(by: CGFloat(5.0))
        xyTimes5XPlus3.translateX(by: CGFloat(3.0), yBy: CGFloat())

        checkPointTransformation(xyTimes5XPlus3, point: NSPoint(x: 1.0, y: 2.0),
                                         expectedPoint: NSPoint(x: 20.0, y: 10.0))
    }
    
    func test_AppendTransform() {
        let point = NSPoint(x: 10.0, y: 10.0)

        var identityTransform = AffineTransform()
        identityTransform.append(identityTransform)
        checkPointTransformation(NSAffineTransform(transform: identityTransform), point: point, expectedPoint: point)
        
        var translate = AffineTransform()
        translate.translate(x: CGFloat(10.0), y: CGFloat())
        
        var scale = AffineTransform()
        scale.scale(CGFloat(2.0))
        
        let translateThenScale = NSAffineTransform(transform: translate)
        translateThenScale.append(scale)
        checkPointTransformation(translateThenScale, point: point, expectedPoint: NSPoint(x: 40.0, y: 20.0))
    }
    
    func test_PrependTransform() {
        let point = NSPoint(x: 10.0, y: 10.0)
        
        var identityTransform = AffineTransform()
        identityTransform.prepend(identityTransform)
        checkPointTransformation(NSAffineTransform(transform: identityTransform), point: point, expectedPoint: point)
        
        var translate = AffineTransform()
        translate.translate(x: CGFloat(10.0), y: CGFloat())
        
        var scale = AffineTransform()
        scale.scale(CGFloat(2.0))
        
        let scaleThenTranslate = NSAffineTransform(transform: translate)
        scaleThenTranslate.prepend(scale)
        checkPointTransformation(scaleThenTranslate, point: point, expectedPoint: NSPoint(x: 30.0, y: 20.0))
    }
    
    
    func test_TransformComposition() {
        let origin = NSPoint(x: 10.0, y: 10.0)
        let size = NSSize(width: 40.0, height: 20.0)
        let rect = NSRect(origin: origin, size: size)
        let center = NSPoint(x: rect.midX, y: rect.midY)
        
        let rotate = NSAffineTransform()
        rotate.rotate(byDegrees: CGFloat(90.0))
        
        var moveOrigin = AffineTransform()
        moveOrigin.translate(x: -center.x, y: -center.y)
        
        var moveBack = moveOrigin
        moveBack.invert()
        
        let rotateAboutCenter = rotate
        rotateAboutCenter.prepend(moveOrigin)
        rotateAboutCenter.append(moveBack)
        
        // center of rect shouldn't move as its the rotation anchor
        checkPointTransformation(rotateAboutCenter, point: center, expectedPoint: center)
    }

    func test_hashing() {
        let a = AffineTransform(m11: 1.0, m12: 2.5, m21: 66.2, m22: 40.2, tX: -5.5, tY: 3.7)
        let b = AffineTransform(m11: -55.66, m12: 22.7, m21: 1.5, m22: 0.0, tX: -22, tY: -33)
        let c = AffineTransform(m11: 4.5, m12: 1.1, m21: 0.025, m22: 0.077, tX: -0.55, tY: 33.2)
        let d = AffineTransform(m11: 7.0, m12: -2.3, m21: 6.7, m22: 0.25, tX: 0.556, tY: 0.99)
        let e = AffineTransform(m11: 0.498, m12: -0.284, m21: -0.742, m22: 0.3248, tX: 12, tY: 44)

        // Samples testing that every component is properly hashed
        let x1 = AffineTransform(m11: 1.0, m12: 2.0, m21: 3.0, m22: 4.0, tX: 5.0, tY: 6.0)
        let x2 = AffineTransform(m11: 1.5, m12: 2.0, m21: 3.0, m22: 4.0, tX: 5.0, tY: 6.0)
        let x3 = AffineTransform(m11: 1.0, m12: 2.5, m21: 3.0, m22: 4.0, tX: 5.0, tY: 6.0)
        let x4 = AffineTransform(m11: 1.0, m12: 2.0, m21: 3.5, m22: 4.0, tX: 5.0, tY: 6.0)
        let x5 = AffineTransform(m11: 1.0, m12: 2.0, m21: 3.0, m22: 4.5, tX: 5.0, tY: 6.0)
        let x6 = AffineTransform(m11: 1.0, m12: 2.0, m21: 3.0, m22: 4.0, tX: 5.5, tY: 6.0)
        let x7 = AffineTransform(m11: 1.0, m12: 2.0, m21: 3.0, m22: 4.0, tX: 5.0, tY: 6.5)

        @inline(never)
        func bridged(_ t: AffineTransform) -> NSAffineTransform {
            return t as NSAffineTransform
        }

        let values: [[AffineTransform]] = [
            [AffineTransform.identity, NSAffineTransform() as AffineTransform],
            [a, bridged(a) as AffineTransform],
            [b, bridged(b) as AffineTransform],
            [c, bridged(c) as AffineTransform],
            [d, bridged(d) as AffineTransform],
            [e, bridged(e) as AffineTransform],
            [x1], [x2], [x3], [x4], [x5], [x6], [x7]
        ]
        checkHashableGroups(values)
    }

    func test_rotation_compose() {
        var t = AffineTransform.identity
        t.translate(x: 1.0, y: 1.0)
        t.rotate(byDegrees: 90)
        t.translate(x: -1.0, y: -1.0)
        let result = t.transform(NSPoint(x: 1.0, y: 2.0))
        XCTAssertEqual(0.0, Double(result.x), accuracy: accuracyThreshold)
        XCTAssertEqual(1.0, Double(result.y), accuracy: accuracyThreshold)
    }

    func test_translation_and_rotation() {
        let point = NSPoint(x: 10, y: 10)
        var translateThenRotate = AffineTransform(translationByX: 20, byY: -30)
        translateThenRotate.rotate(byRadians: .pi / 2)
        checkPointTransformation(NSAffineTransform(transform: translateThenRotate), point: point, expectedPoint: NSPoint(x: 10, y: -20))
    }

    func test_Equal() {
        let transform = NSAffineTransform()
        let transform1 = NSAffineTransform()
        
        XCTAssertEqual(transform1, transform)
        XCTAssertFalse(transform === transform1)
    }
    
    func test_NSCoding() {
        let transformA = NSAffineTransform()
        transformA.scale(by: 2)
        let transformB = NSKeyedUnarchiver.unarchiveObject(with: NSKeyedArchiver.archivedData(withRootObject: transformA)) as! NSAffineTransform
        XCTAssertEqual(transformA, transformB, "Archived then unarchived `NSAffineTransform` must be equal.")
    }
}

extension NSAffineTransform {
    func transformRect(_ aRect: NSRect) -> NSRect {
        return NSRect(origin: transform(aRect.origin), size: transform(aRect.size))
    }
}