open class HeartLayer: CALayer {

    fileprivate struct Durations {
        static let Full: TimeInterval = 3
        static let Bloom: TimeInterval = 0.5
    }

    public init(frame: CGRect) {
        super.init()
        position = frame.origin
        bounds = frame
        backgroundColor = UIColor.clear.cgColor
        anchorPoint = CGPoint(x: 0.5, y: 1)
        contents = #imageLiteral(resourceName: "heart").cgImage
    }

    required public init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
    }

    // MARK: Animations

    open func animateInView(_ view: UIView) {

        prepareForAnimation()
        performBloomAnimation()
        addPathAnimation(inView: view)
    }

    fileprivate func prepareForAnimation() {
//        transform = CGAffineTransform(scaleX: 0, y: 0)
//        transform = CATransform3D(
//        alpha = 0
    }

    fileprivate func performBloomAnimation() {

        spring(Durations.Bloom, delay: 0.0, damping: 0.6, velocity: 0.8) {
            //f.alpha = 0.9
        }
    }

    fileprivate func slightRotationAnimation(withDuration duration: TimeInterval = Durations.Full, _ direction: RotationDirection) {
        let rotationFraction = randomNumber(10)
        let rotate = CABasicAnimation(keyPath: "transform.rotation")
        rotate.fromValue = 0
        rotate.toValue =  direction.rawValue * PI / (16 + rotationFraction * 0.2)
        rotate.duration = Durations.Full
        rotate.fillMode = kCAFillModeForwards;
        rotate.isRemovedOnCompletion = false
        add(rotate, forKey: "transform.rotation")
    }

    fileprivate func travelPath(inView view: UIView) -> UIBezierPath? {
        guard let endPointDirection = RotationDirection(rawValue: CGFloat(1 - Int(2 * randomNumber(2)))) else { return nil }

        let heartCenterX = position.x + bounds.width / 2
        let heartSize = bounds.width
        let viewHeight = view.bounds.height

        //random end point
        let endPointX = heartCenterX + (endPointDirection.rawValue * randomNumber(2 * heartSize))
        let endPointY = viewHeight - (viewHeight / 6.0 + randomNumber(viewHeight / 4.0))
        let endPoint = CGPoint(x: endPointX, y: endPointY)

        //random Control Points
        let travelDirection = CGFloat(1 - Int(2 * randomNumber(2)))
        let xDelta = (heartSize / 2.0 + randomNumber(2 * heartSize)) * travelDirection
        let yDelta = max(endPoint.y ,max(randomNumber(8 * heartSize), heartSize))
        let controlPoint1 = CGPoint(x: heartCenterX + xDelta, y: viewHeight - yDelta)
        let controlPoint2 = CGPoint(x: heartCenterX - 2 * xDelta, y: yDelta)

        let path = UIBezierPath()
        let center = CGPoint(x: position.x + bounds.width / 2, y: position.y + bounds.height / 2)
        path.move(to: center)
        path.addCurve(to: endPoint, controlPoint1: controlPoint1, controlPoint2: controlPoint2)
        return path
    }

    fileprivate func addPathAnimation(inView view: UIView) {
        guard let heartTravelPath = travelPath(inView: view) else { return }
        let keyFrameAnimation = CAKeyframeAnimation(keyPath: "position")
        keyFrameAnimation.path = heartTravelPath.cgPath
        keyFrameAnimation.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionLinear)
        let durationAdjustment = 4 * TimeInterval(heartTravelPath.bounds.height / view.bounds.height)
        let duration = Durations.Full + durationAdjustment
        keyFrameAnimation.duration = duration

        add(keyFrameAnimation, forKey: "positionOnPath")

        animateToFinalAlpha(withDuration: duration)

        guard let rotationDirection = RotationDirection(rawValue: CGFloat(1 - Int(2 * randomNumber(2)))) else { return }
        slightRotationAnimation(withDuration: duration, rotationDirection)
    }

    fileprivate func animateToFinalAlpha(withDuration duration: TimeInterval = Durations.Full) {
        let animation = CABasicAnimation(keyPath: "opacity")
        animation.fromValue = 1
        animation.toValue = 0
        animation.duration = duration
        animation.delegate = self
        animation.fillMode = kCAFillModeForwards;
        animation.isRemovedOnCompletion = false
        add(animation, forKey: "hide")

    }
}

extension HeartLayer: CAAnimationDelegate {
    public func animationDidStop(_ anim: CAAnimation, finished flag: Bool) {
        removeFromSuperlayer()
    }
}