//
//  RSTimingFunction.m
//
//  Created by Raphael Schaad https://github.com/raphaelschaad on 2013-09-28.
//  This is free and unencumbered software released into the public domain.
//  The cubic Bezier math code is licensed under its original copyright notice included below.
//  You can use this code (e.g. in your iOS project) without worries as long as you don't remove that notice.
//


#import "RSTimingFunction.h"
#include <tgmath.h> // type generic math, yo: http://en.wikipedia.org/wiki/Tgmath.h#tgmath.h


// Same values as `CAMediaTimingFunction` defines, so they can be used interchangeably.
NSString * const kRSTimingFunctionLinear        = @"linear";
NSString * const kRSTimingFunctionEaseIn        = @"easeIn";
NSString * const kRSTimingFunctionEaseOut       = @"easeOut";
NSString * const kRSTimingFunctionEaseInEaseOut = @"easeInEaseOut";
NSString * const kRSTimingFunctionDefault       = @"default";


// Replicate exact same curves as `CAMediaTimingFunction` defines.
static const CGPoint kLinearP1        = {0.0,  0.0};
static const CGPoint kLinearP2        = {1.0,  1.0};
static const CGPoint kEaseInP1        = {0.42, 0.0};
static const CGPoint kEaseInP2        = {1.0,  1.0};
static const CGPoint kEaseOutP1       = {0.0,  0.0};
static const CGPoint kEaseOutP2       = {0.58, 1.0};
static const CGPoint kEaseInEaseOutP1 = {0.42, 0.0};
static const CGPoint kEaseInEaseOutP2 = {0.58, 1.0};
static const CGPoint kDefaultP1       = {0.25, 0.1};
static const CGPoint kDefaultP2       = {0.25, 1.0};


// NSCoding
static NSString * const kControlPoint1Key = @"controlPoint1";
static NSString * const kControlPoint2Key = @"controlPoint2";
static NSString * const kDurationKey = @"duration";


// Internal constants
static const NSTimeInterval kDurationDefault = 1.0;


// For once use private ivars instead of properties for code readability (also omit leading underscore) and to avoid performance hits.
@interface RSTimingFunction ()
{
    // Polynomial coefficients
    CGFloat ax;
    CGFloat bx;
    CGFloat cx;
    
    CGFloat ay;
    CGFloat by;
    CGFloat cy;
}
@end


@implementation RSTimingFunction

#pragma mark - Accessors

@synthesize controlPoint1 = p1;

- (void)setControlPoint1:(CGPoint)controlPoint1
{
    if (!CGPointEqualToPoint(p1, [[self class] normalizedPoint:controlPoint1])) {
        p1 = controlPoint1;
        
        [self calculatePolynomialCoefficients];
    }
}


@synthesize controlPoint2 = p2;

- (void)setControlPoint2:(CGPoint)controlPoint2
{
    if (!CGPointEqualToPoint(p2, [[self class] normalizedPoint:controlPoint2])) {
        p2 = controlPoint2;
        
        [self calculatePolynomialCoefficients];
    }
}


@synthesize duration = dur;

- (void)setDuration:(NSTimeInterval)duration
{
    // Only allow non-negative durations.
    duration = MAX(0.0, duration);
    if (dur != duration) {
        dur = duration;
    }
}


#pragma mark - Life Cycle

// Privat designated initializer
- (instancetype)initWithControlPoint1:(CGPoint)controlPoint1 controlPoint2:(CGPoint)controlPoint2 duration:(NSTimeInterval)duration
{
    self = [super init];
    if (self) {
        // Don't initialize control points through setter to avoid triggering `-calculatePolynomicalCoefficients` unnecessarily twice.
        p1 = [[self class] normalizedPoint:controlPoint1];
        p2 = [[self class] normalizedPoint:controlPoint2];
        
        // Manually initialize polynomial coefficients with newly set control points.
        [self calculatePolynomialCoefficients];
        
        // Use setter to leverage its value sanitanization.
        self.duration = duration;
    }
    return self;
}


- (instancetype)initWithName:(NSString *)name
{
    CGPoint controlPoint1 = [[self class] controlPoint1ForTimingFunctionWithName:name];
    CGPoint controlPoint2 = [[self class] controlPoint2ForTimingFunctionWithName:name];
    return [self initWithControlPoint1:controlPoint1 controlPoint2:controlPoint2];
}


+ (instancetype)timingFunctionWithName:(NSString *)name
{
    return [[self alloc] initWithName:name];
}


- (instancetype)initWithControlPoint1:(CGPoint)controlPoint1 controlPoint2:(CGPoint)controlPoint2
{
    return [self initWithControlPoint1:controlPoint1 controlPoint2:controlPoint2 duration:kDurationDefault];
}


+ (instancetype)timingFunctionWithControlPoint1:(CGPoint)controlPoint1 controlPoint2:(CGPoint)controlPoint2
{
    return [[self alloc] initWithControlPoint1:controlPoint1 controlPoint2:controlPoint2];
}


#pragma mark - NSObject Method Overrides
#pragma mark Describing Objects

- (NSString *)description
{
    NSString *description = [super description];
    
    description = [description stringByAppendingFormat:@" controlPoint1 = %@;", NSStringFromCGPoint(self.controlPoint1)];
    description = [description stringByAppendingFormat:@" controlPoint2 = %@;", NSStringFromCGPoint(self.controlPoint2)];
    description = [description stringByAppendingFormat:@" duration = %f;", self.duration];
    
    return description;
}


- (NSString *)debugDescription
{
    NSString *debugDescription = [self description];
    
    debugDescription = [debugDescription stringByAppendingFormat:@" ax = %f;", ax];
    debugDescription = [debugDescription stringByAppendingFormat:@" bx = %f;", bx];
    debugDescription = [debugDescription stringByAppendingFormat:@" cx = %f;", cx];
    
    debugDescription = [debugDescription stringByAppendingFormat:@" ay = %f;", ay];
    debugDescription = [debugDescription stringByAppendingFormat:@" by = %f;", by];
    debugDescription = [debugDescription stringByAppendingFormat:@" cy = %f;", cy];
    
    return debugDescription;
}


#pragma mark - NSCoding Protocol

- (id)initWithCoder:(NSCoder *)decoder
{
    CGPoint controlPoint1 = [decoder decodeCGPointForKey:kControlPoint1Key];
    CGPoint controlPoint2 = [decoder decodeCGPointForKey:kControlPoint2Key];
    NSTimeInterval duration = [decoder decodeDoubleForKey:kDurationKey];
    
    return [self initWithControlPoint1:controlPoint1 controlPoint2:controlPoint2 duration:duration];
}


- (void)encodeWithCoder:(NSCoder *)encoder
{
    [encoder encodeCGPoint:self.controlPoint1 forKey:kControlPoint1Key];
    [encoder encodeCGPoint:self.controlPoint2 forKey:kControlPoint2Key];
    [encoder encodeDouble:self.duration forKey:kDurationKey];
}


#pragma mark - Public Methods

- (CGFloat)valueForX:(CGFloat)x
{
    CGFloat epsilon = [self epsilon];
    CGFloat xSolved = [self solveCurveX:x epsilon:epsilon];
    CGFloat y = [self sampleCurveY:xSolved];
    return y;
}


#pragma mark - Private Methods
#pragma mark Cubic Bezier Math

// Cubic Bezier math code is based on WebCore (WebKit)
// http://opensource.apple.com/source/WebCore/WebCore-955.66/platform/graphics/UnitBezier.h
// http://opensource.apple.com/source/WebCore/WebCore-955.66/page/animation/AnimationBase.cpp

/*
 * Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
 *     its contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


- (CGFloat)epsilon
{
    // Higher precision in the timing function for longer duration to avoid ugly discontinuities
    return 1.0 / (200.0 * dur);
}


- (void)calculatePolynomialCoefficients
{
    // Implicit first and last control points are (0,0) and (1,1).
    cx = 3.0 * p1.x;
    bx = 3.0 * (p2.x - p1.x) - cx;
    ax = 1.0 - cx - bx;
    
    cy = 3.0 * p1.y;
    by = 3.0 * (p2.y - p1.y) - cy;
    ay = 1.0 - cy - by;
}


- (CGFloat)sampleCurveX:(CGFloat)t
{
    // 'ax t^3 + bx t^2 + cx t' expanded using Horner's rule.
    return ((ax * t + bx) * t + cx) * t;
}


- (CGFloat)sampleCurveY:(CGFloat)t
{
    return ((ay * t + by) * t + cy) * t;
}


- (CGFloat)sampleCurveDerivativeX:(CGFloat)t
{
    return (3.0 * ax * t + 2.0 * bx) * t + cx;
}


// Given an x value, find a parametric value it came from.
- (CGFloat)solveCurveX:(CGFloat)x epsilon:(CGFloat)epsilon
{
    CGFloat t0;
    CGFloat t1;
    CGFloat t2;
    CGFloat x2;
    CGFloat d2;
    NSUInteger i;
    
    // First try a few iterations of Newton's method -- normally very fast.
    for (t2 = x, i = 0; i < 8; i++) {
        x2 = [self sampleCurveX:t2] - x;
        if (fabs(x2) < epsilon) {
            return t2;
        }
        d2 = [self sampleCurveDerivativeX:t2];
        if (fabs(d2) < 1e-6) {
            break;
        }
        t2 = t2 - x2 / d2;
    }
    
    // Fall back to the bisection method for reliability.
    t0 = 0.0;
    t1 = 1.0;
    t2 = x;
    
    if (t2 < t0) {
        return t0;
    }
    if (t2 > t1) {
        return t1;
    }
    
    while (t0 < t1) {
        x2 = [self sampleCurveX:t2];
        if (fabs(x2 - x) < epsilon) {
            return t2;
        }
        if (x > x2) {
            t0 = t2;
        } else {
            t1 = t2;
        }
        t2 = (t1 - t0) * 0.5 + t0;
    }
    
    // Failure.
    return t2;
}


#pragma mark Helpers

+ (CGPoint)normalizedPoint:(CGPoint)point
{
    CGPoint normalizedPoint = CGPointZero;
    
    // Clamp to interval [0..1]
    normalizedPoint.x = MAX(0.0, MIN(1.0, point.x));
    normalizedPoint.y = MAX(0.0, MIN(1.0, point.y));
    
    return normalizedPoint;
}


+ (CGPoint)controlPoint1ForTimingFunctionWithName:(NSString *)name
{
    CGPoint controlPoint1 = CGPointZero;
    
    if ([name isEqual:kRSTimingFunctionLinear]) {
        controlPoint1 = kLinearP1;
    } else if ([name isEqual:kRSTimingFunctionEaseIn]) {
        controlPoint1 = kEaseInP1;
    } else if ([name isEqual:kRSTimingFunctionEaseOut]) {
        controlPoint1 = kEaseOutP1;
    } else if ([name isEqual:kRSTimingFunctionEaseInEaseOut]) {
        controlPoint1 = kEaseInEaseOutP1;
    } else if ([name isEqual:kRSTimingFunctionDefault]) {
        controlPoint1 = kDefaultP1;
    } else {
        // Not a predefined timing function
    }
    
    return controlPoint1;
}


+ (CGPoint)controlPoint2ForTimingFunctionWithName:(NSString *)name
{
    CGPoint controlPoint2 = CGPointZero;
    
    if ([name isEqual:kRSTimingFunctionLinear]) {
        controlPoint2 = kLinearP2;
    } else if ([name isEqual:kRSTimingFunctionEaseIn]) {
        controlPoint2 = kEaseInP2;
    } else if ([name isEqual:kRSTimingFunctionEaseOut]) {
        controlPoint2 = kEaseOutP2;
    } else if ([name isEqual:kRSTimingFunctionEaseInEaseOut]) {
        controlPoint2 = kEaseInEaseOutP2;
    } else if ([name isEqual:kRSTimingFunctionDefault]) {
        controlPoint2 = kDefaultP2;
    } else {
        // Not a predefined timing function
    }
    
    return controlPoint2;
}


@end