// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// RUN: %target-run-simple-swift
// REQUIRES: executable_test
// REQUIRES: objc_interop

import Foundation

#if os(macOS)

#if FOUNDATION_XCTEST
import XCTest
class TestAffineTransformSuper : XCTestCase { }
#else
import StdlibUnittest
class TestAffineTransformSuper { }
#endif

func expectEqualWithAccuracy(_ lhs: Double, _ rhs: Double, accuracy: Double, _ message: String = "", file: String = #file, line: UInt = #line) {
    expectTrue(fabs(lhs - rhs) < accuracy, message, file: file, line: line)
}

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

class TestAffineTransform : TestAffineTransformSuper {
    private let accuracyThreshold = 0.001
    
    func checkPointTransformation(_ transform: AffineTransform, point: NSPoint, expectedPoint: NSPoint, _ message: String = "", file: String = #file, line: UInt = #line) {
        let newPoint = transform.transform(point)
        expectEqualWithAccuracy(Double(newPoint.x), Double(expectedPoint.x), accuracy: accuracyThreshold,
                                   "x (expected: \(expectedPoint.x), was: \(newPoint.x)): \(message)", file: file, line: line)
        expectEqualWithAccuracy(Double(newPoint.y), Double(expectedPoint.y), accuracy: accuracyThreshold,
                                   "y (expected: \(expectedPoint.y), was: \(newPoint.y)): \(message)", file: file, line: line)
    }
    
    func checkSizeTransformation(_ transform: AffineTransform, size: NSSize, expectedSize: NSSize, _ message: String = "", file: String = #file, line: UInt = #line) {
        let newSize = transform.transform(size)
        expectEqualWithAccuracy(Double(newSize.width), Double(expectedSize.width), accuracy: accuracyThreshold,
                                   "width (expected: \(expectedSize.width), was: \(newSize.width)): \(message)", file: file, line: line)
        expectEqualWithAccuracy(Double(newSize.height), Double(expectedSize.height), accuracy: accuracyThreshold,
                                   "height (expected: \(expectedSize.height), was: \(newSize.height)): \(message)", file: file, line: line)
    }
    
    func checkRectTransformation(_ transform: AffineTransform, rect: NSRect, expectedRect: NSRect, _ message: String = "", file: String = #file, line: UInt = #line) {
        let newRect = transform.transform(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 defaultAffineTransform = AffineTransform()
        let identityTransform = AffineTransform.identity

        expectEqual(defaultAffineTransform, identityTransform)
        
        // 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
        expectEqualWithAccuracy(Double(identityTransform.m11), Double(1), accuracy: accuracyThreshold)
        expectEqualWithAccuracy(Double(identityTransform.m22), Double(1), accuracy: accuracyThreshold)
        
        expectEqualWithAccuracy(Double(identityTransform.m12), Double(0), accuracy: accuracyThreshold)
        expectEqualWithAccuracy(Double(identityTransform.m21), Double(0), accuracy: accuracyThreshold)
        expectEqualWithAccuracy(Double(identityTransform.tX), Double(0), accuracy: accuracyThreshold)
        expectEqualWithAccuracy(Double(identityTransform.tY), Double(0), accuracy: accuracyThreshold)
    }
    
    func test_IdentityTransformation() {
        let identityTransform = AffineTransform.identity
        
        func checkIdentityPointTransformation(_ point: NSPoint) {
            checkPointTransformation(identityTransform, point: point, expectedPoint: point)
        }
        
        checkIdentityPointTransformation(NSPoint())
        checkIdentityPointTransformation(NSPoint(x: CGFloat(24.5), y: CGFloat(10.0)))
        checkIdentityPointTransformation(NSPoint(x: CGFloat(-7.5), y: CGFloat(2.0)))
        
        func checkIdentitySizeTransformation(_ size: NSSize) {
            checkSizeTransformation(identityTransform, size: size, expectedSize: size)
        }
        
        checkIdentitySizeTransformation(NSSize())
        checkIdentitySizeTransformation(NSSize(width: CGFloat(13.0), height: CGFloat(12.5)))
        checkIdentitySizeTransformation(NSSize(width: CGFloat(100.0), height: CGFloat(-100.0)))
    }
    
    func test_Translation() {
        let point = NSPoint(x: CGFloat(0.0), y: CGFloat(0.0))
        
        var noop = AffineTransform.identity
        noop.translate(x: CGFloat(), y: CGFloat())
        checkPointTransformation(noop, point: point, expectedPoint: point)
        
        var translateH = AffineTransform.identity
        translateH.translate(x: CGFloat(10.0), y: CGFloat())
        checkPointTransformation(translateH, point: point, expectedPoint: NSPoint(x: CGFloat(10.0), y: CGFloat()))
        
        var translateV = AffineTransform.identity
        translateV.translate(x: CGFloat(), y: CGFloat(20.0))
        checkPointTransformation(translateV, point: point, expectedPoint: NSPoint(x: CGFloat(), y: CGFloat(20.0)))
        
        var translate = AffineTransform.identity
        translate.translate(x: CGFloat(-30.0), y: CGFloat(40.0))
        checkPointTransformation(translate, point: point, expectedPoint: NSPoint(x: CGFloat(-30.0), y: CGFloat(40.0)))
    }
    
    func test_Scale() {
        let size = NSSize(width: CGFloat(10.0), height: CGFloat(10.0))
        
        var noop = AffineTransform.identity
        noop.scale(CGFloat(1.0))
        checkSizeTransformation(noop, size: size, expectedSize: size)
        
        var shrink = AffineTransform.identity
        shrink.scale(CGFloat(0.5))
        checkSizeTransformation(shrink, size: size, expectedSize: NSSize(width: CGFloat(5.0), height: CGFloat(5.0)))
        
        var grow = AffineTransform.identity
        grow.scale(CGFloat(3.0))
        checkSizeTransformation(grow, size: size, expectedSize: NSSize(width: CGFloat(30.0), height: CGFloat(30.0)))
        
        var stretch = AffineTransform.identity
        stretch.scale(x: CGFloat(2.0), y: CGFloat(0.5))
        checkSizeTransformation(stretch, size: size, expectedSize: NSSize(width: CGFloat(20.0), height: CGFloat(5.0)))
    }
    
    func test_Rotation_Degrees() {
        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
        
        var noop = AffineTransform.identity
        noop.rotate(byDegrees: CGFloat())
        checkPointTransformation(noop, point: point, expectedPoint: point)
        
        var tenEighty = AffineTransform.identity
        tenEighty.rotate(byDegrees: CGFloat(1080.0))
        checkPointTransformation(tenEighty, point: point, expectedPoint: point)
        
        var rotateCounterClockwise = AffineTransform.identity
        rotateCounterClockwise.rotate(byDegrees: CGFloat(90.0))
        checkPointTransformation(rotateCounterClockwise, point: point, expectedPoint: NSPoint(x: CGFloat(-10.0), y: CGFloat(10.0)))
        
        var rotateClockwise = AffineTransform.identity
        rotateClockwise.rotate(byDegrees: CGFloat(-90.0))
        checkPointTransformation(rotateClockwise, point: point, expectedPoint: NSPoint(x: CGFloat(10.0), y: CGFloat(-10.0)))
        
        var reflectAboutOrigin = AffineTransform.identity
        reflectAboutOrigin.rotate(byDegrees: CGFloat(180.0))
        checkPointTransformation(reflectAboutOrigin, point: point, expectedPoint: NSPoint(x: CGFloat(-10.0), y: CGFloat(-10.0)))
    }
    
    func test_Rotation_Radians() {
        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
        
        var noop = AffineTransform.identity
        noop.rotate(byRadians: CGFloat())
        checkPointTransformation(noop, point: point, expectedPoint: point)
        
        var tenEighty = AffineTransform.identity
        tenEighty.rotate(byRadians: 6 * .pi)
        checkPointTransformation(tenEighty, point: point, expectedPoint: point)
        
        var rotateCounterClockwise = AffineTransform.identity
        rotateCounterClockwise.rotate(byRadians: .pi / 2)
        checkPointTransformation(rotateCounterClockwise, point: point, expectedPoint: NSPoint(x: CGFloat(-10.0), y: CGFloat(10.0)))
        
        var rotateClockwise = AffineTransform.identity
        rotateClockwise.rotate(byRadians: -.pi / 2)
        checkPointTransformation(rotateClockwise, point: point, expectedPoint: NSPoint(x: CGFloat(10.0), y: CGFloat(-10.0)))
        
        var reflectAboutOrigin = AffineTransform.identity
        reflectAboutOrigin.rotate(byRadians: .pi)
        checkPointTransformation(reflectAboutOrigin, point: point, expectedPoint: NSPoint(x: CGFloat(-10.0), y: CGFloat(-10.0)))
        
        var scaleThenRotate = AffineTransform(scale: 2)
        scaleThenRotate.rotate(byRadians: .pi / 2)
        checkPointTransformation(scaleThenRotate, point: point, expectedPoint: NSPoint(x: CGFloat(-20.0), y: CGFloat(20.0)))
    }
    
    func test_Inversion() {
        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
        
        var translate = AffineTransform.identity
        translate.translate(x: CGFloat(-30.0), y: CGFloat(40.0))
        
        var rotate = AffineTransform.identity
        translate.rotate(byDegrees: CGFloat(30.0))
        
        var scale = AffineTransform.identity
        scale.scale(CGFloat(2.0))
        
        var identityTransform = AffineTransform.identity
        
        // 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() {
        var xyPlus5 = AffineTransform.identity
        xyPlus5.translate(x: CGFloat(2.0), y: CGFloat(3.0))
        xyPlus5.translate(x: CGFloat(3.0), y: CGFloat(2.0))
        
        checkPointTransformation(xyPlus5, point: NSPoint(x: CGFloat(-2.0), y: CGFloat(-3.0)),
                                 expectedPoint: NSPoint(x: CGFloat(3.0), y: CGFloat(2.0)))
    }
    
    func test_Scaling() {
        var xyTimes5 = AffineTransform.identity
        xyTimes5.scale(CGFloat(5.0))
        
        checkPointTransformation(xyTimes5, point: NSPoint(x: CGFloat(-2.0), y: CGFloat(3.0)),
                                 expectedPoint: NSPoint(x: CGFloat(-10.0), y: CGFloat(15.0)))
        
        var xTimes2YTimes3 = AffineTransform.identity
        xTimes2YTimes3.scale(x: CGFloat(2.0), y: CGFloat(-3.0))
        
        checkPointTransformation(xTimes2YTimes3, point: NSPoint(x: CGFloat(-1.0), y: CGFloat(3.5)),
                                 expectedPoint: NSPoint(x: CGFloat(-2.0), y: CGFloat(-10.5)))
    }
    
    func test_TranslationScaling() {
        var xPlus2XYTimes5 = AffineTransform.identity
        xPlus2XYTimes5.translate(x: CGFloat(2.0), y: CGFloat())
        xPlus2XYTimes5.scale(x: CGFloat(5.0), y: CGFloat(-5.0))
        
        checkPointTransformation(xPlus2XYTimes5, point: NSPoint(x: CGFloat(1.0), y: CGFloat(2.0)),
                                 expectedPoint: NSPoint(x: CGFloat(7.0), y: CGFloat(-10.0)))
    }
    
    func test_ScalingTranslation() {
        var xyTimes5XPlus3 = AffineTransform.identity
        xyTimes5XPlus3.scale(CGFloat(5.0))
        xyTimes5XPlus3.translate(x: CGFloat(3.0), y: CGFloat())
        
        checkPointTransformation(xyTimes5XPlus3, point: NSPoint(x: CGFloat(1.0), y: CGFloat(2.0)),
                                 expectedPoint: NSPoint(x: CGFloat(20.0), y: CGFloat(10.0)))
    }
    
    func test_AppendTransform() {
        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
        
        var identityTransform = AffineTransform.identity
        identityTransform.append(identityTransform)
        checkPointTransformation(identityTransform, point: point, expectedPoint: point)
        
        let translate = AffineTransform(translationByX: 10.0, byY: 0.0)
        
        let scale = AffineTransform(scale: 2.0)
        
        var translateThenScale = translate
        translateThenScale.append(scale)
        checkPointTransformation(translateThenScale, point: point, expectedPoint: NSPoint(x: CGFloat(40.0), y: CGFloat(20.0)))
    }
    
    func test_PrependTransform() {
        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
        
        var identityTransform = AffineTransform.identity
        identityTransform.append(identityTransform)
        checkPointTransformation(identityTransform, point: point, expectedPoint: point)
        
        let translate = AffineTransform(translationByX: 10.0, byY: 0.0)
        
        let scale = AffineTransform(scale: 2.0)
        
        var scaleThenTranslate = translate
        scaleThenTranslate.prepend(scale)
        checkPointTransformation(scaleThenTranslate, point: point, expectedPoint: NSPoint(x: CGFloat(30.0), y: CGFloat(20.0)))
    }
    
    func test_TransformComposition() {
        let origin = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
        let size = NSSize(width: CGFloat(40.0), height: CGFloat(20.0))
        let rect = NSRect(origin: origin, size: size)
        let center = NSPoint(x: NSMidX(rect), y: NSMidY(rect))
        
        let rotate = AffineTransform(rotationByDegrees: 90.0)
        
        let moveOrigin = AffineTransform(translationByX: -center.x, byY: -center.y)
        
        var moveBack = moveOrigin
        moveBack.invert()
        
        var 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_identity() {
        let ref = NSAffineTransform()
        let val = AffineTransform.identity
        expectEqual(ref.hashValue, val.hashValue)
    }
    
    func test_hashing_values() {
        // the transforms are made up and the values don't matter
        let values = [
            AffineTransform(m11: 1.0, m12: 2.5, m21: 66.2, m22: 40.2, tX: -5.5, tY: 3.7),
            AffineTransform(m11: -55.66, m12: 22.7, m21: 1.5, m22: 0.0, tX: -22, tY: -33),
            AffineTransform(m11: 4.5, m12: 1.1, m21: 0.025, m22: 0.077, tX: -0.55, tY: 33.2),
            AffineTransform(m11: 7.0, m12: -2.3, m21: 6.7, m22: 0.25, tX: 0.556, tY: 0.99),
            AffineTransform(m11: 0.498, m12: -0.284, m21: -0.742, m22: 0.3248, tX: 12, tY: 44)
        ]
        for val in values {
            let ref = val as NSAffineTransform
            expectEqual(ref.hashValue, val.hashValue)
        }
    }

    func test_AnyHashableContainingAffineTransform() {
        let values: [AffineTransform] = [
            AffineTransform.identity,
            AffineTransform(m11: -55.66, m12: 22.7, m21: 1.5, m22: 0.0, tX: -22, tY: -33),
            AffineTransform(m11: -55.66, m12: 22.7, m21: 1.5, m22: 0.0, tX: -22, tY: -33)
        ]
        let anyHashables = values.map(AnyHashable.init)
        expectEqual(AffineTransform.self, type(of: anyHashables[0].base))
        expectEqual(AffineTransform.self, type(of: anyHashables[1].base))
        expectEqual(AffineTransform.self, type(of: anyHashables[2].base))
        expectNotEqual(anyHashables[0], anyHashables[1])
        expectEqual(anyHashables[1], anyHashables[2])
    }

    func test_AnyHashableCreatedFromNSAffineTransform() {
        func makeNSAffineTransform(rotatedByDegrees angle: CGFloat) -> NSAffineTransform {
            let result = NSAffineTransform()
            result.rotate(byDegrees: angle)
            return result
        }
        let values: [NSAffineTransform] = [
            makeNSAffineTransform(rotatedByDegrees: 0),
            makeNSAffineTransform(rotatedByDegrees: 10),
            makeNSAffineTransform(rotatedByDegrees: 10),
        ]
        let anyHashables = values.map(AnyHashable.init)
        expectEqual(AffineTransform.self, type(of: anyHashables[0].base))
        expectEqual(AffineTransform.self, type(of: anyHashables[1].base))
        expectEqual(AffineTransform.self, type(of: anyHashables[2].base))
        expectNotEqual(anyHashables[0], anyHashables[1])
        expectEqual(anyHashables[1], anyHashables[2])
    }

    func test_unconditionallyBridgeFromObjectiveC() {
        expectEqual(AffineTransform(), AffineTransform._unconditionallyBridgeFromObjectiveC(nil))
    }

    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))
        expectEqualWithAccuracy(0.0, Double(result.x), accuracy: accuracyThreshold)
        expectEqualWithAccuracy(1.0, Double(result.y), accuracy: accuracyThreshold)
    }
}

#if !FOUNDATION_XCTEST
var AffineTransformTests = TestSuite("TestAffineTransform")
AffineTransformTests.test("test_BasicConstruction") { TestAffineTransform().test_BasicConstruction() }
AffineTransformTests.test("test_IdentityTransformation") { TestAffineTransform().test_IdentityTransformation() }
AffineTransformTests.test("test_Translation") { TestAffineTransform().test_Translation() }
AffineTransformTests.test("test_Scale") { TestAffineTransform().test_Scale() }
AffineTransformTests.test("test_Rotation_Degrees") { TestAffineTransform().test_Rotation_Degrees() }
AffineTransformTests.test("test_Rotation_Radians") { TestAffineTransform().test_Rotation_Radians() }
AffineTransformTests.test("test_Inversion") { TestAffineTransform().test_Inversion() }
AffineTransformTests.test("test_TranslationComposed") { TestAffineTransform().test_TranslationComposed() }
AffineTransformTests.test("test_Scaling") { TestAffineTransform().test_Scaling() }
AffineTransformTests.test("test_TranslationScaling") { TestAffineTransform().test_TranslationScaling() }
AffineTransformTests.test("test_ScalingTranslation") { TestAffineTransform().test_ScalingTranslation() }
AffineTransformTests.test("test_AppendTransform") { TestAffineTransform().test_AppendTransform() }
AffineTransformTests.test("test_PrependTransform") { TestAffineTransform().test_PrependTransform() }
AffineTransformTests.test("test_TransformComposition") { TestAffineTransform().test_TransformComposition() }
AffineTransformTests.test("test_hashing_identity") { TestAffineTransform().test_hashing_identity() }
AffineTransformTests.test("test_hashing_values") { TestAffineTransform().test_hashing_values() }
AffineTransformTests.test("test_AnyHashableContainingAffineTransform") { TestAffineTransform().test_AnyHashableContainingAffineTransform() }
AffineTransformTests.test("test_AnyHashableCreatedFromNSAffineTransform") { TestAffineTransform().test_AnyHashableCreatedFromNSAffineTransform() }
AffineTransformTests.test("test_unconditionallyBridgeFromObjectiveC") { TestAffineTransform().test_unconditionallyBridgeFromObjectiveC() }
AffineTransformTests.test("test_rotation_compose") { TestAffineTransform().test_rotation_compose() }
runAllTests()
#endif
    

#endif