/*
 * Copyright (C) 2016 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.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. 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 INC. 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.
 */

#include "config.h"

#include <WebCore/AffineTransform.h>
#include <WebCore/FloatPoint.h>
#include <WebCore/FloatSize.h>
#include <WebCore/IntPoint.h>
#include <WebCore/IntSize.h>
#include <WebCore/TransformationMatrix.h>

#if USE(CG)
#include <CoreGraphics/CoreGraphics.h>
#endif

#if PLATFORM(WIN)
#include <d2d1.h>
#endif

namespace TestWebKitAPI {

static void testGetAndSet(WebCore::FloatPoint point)
{
    point.setX(1.1f);
    EXPECT_FLOAT_EQ(1.1f, point.x());
    point.setY(2.2f);
    EXPECT_FLOAT_EQ(2.2f, point.y());

    point.set(9.9f, 8.8f);
    EXPECT_FLOAT_EQ(9.9f, point.x());
    EXPECT_FLOAT_EQ(8.8f, point.y());
}

TEST(FloatPoint, DefaultConstruction)
{
    WebCore::FloatPoint test;

    EXPECT_FLOAT_EQ(0, test.x());
    EXPECT_FLOAT_EQ(0, test.y());

    testGetAndSet(test);
}

TEST(FloatPoint, ValueConstruction)
{
    WebCore::FloatPoint test(9.9f, 8.8f);

    EXPECT_FLOAT_EQ(9.9f, test.x());
    EXPECT_FLOAT_EQ(8.8f, test.y());

    testGetAndSet(test);
}

TEST(FloatPoint, ZeroConstruction)
{
    WebCore::FloatPoint test = WebCore::FloatPoint::zero();

    EXPECT_FLOAT_EQ(0, test.x());
    EXPECT_FLOAT_EQ(0, test.y());
}

TEST(FloatPoint, IntPointConstruction)
{
    WebCore::IntPoint testInput(2003, 1997);
    WebCore::FloatPoint test = WebCore::FloatPoint(testInput);

    EXPECT_FLOAT_EQ(2003.0f, test.x());
    EXPECT_FLOAT_EQ(1997.0f, test.y());
}

TEST(FloatPoint, FloatSizeConstruction)
{
    WebCore::FloatSize testInput(500.7f, 300.2f);
    WebCore::FloatPoint test = WebCore::FloatPoint(testInput);

    EXPECT_FLOAT_EQ(500.7, test.x());
    EXPECT_FLOAT_EQ(300.2, test.y());
}

TEST(FloatPoint, MoveByFloat)
{
    WebCore::FloatPoint test(100.0f, 200.0f);

    EXPECT_FLOAT_EQ(100.0f, test.x());
    EXPECT_FLOAT_EQ(200.0f, test.y());

    test.move(20.2f, 30.3f);

    EXPECT_FLOAT_EQ(120.2f, test.x());
    EXPECT_FLOAT_EQ(230.3f, test.y());

    test.move(-81.3f, 10.0f);

    EXPECT_FLOAT_EQ(38.9f, test.x());
    EXPECT_FLOAT_EQ(240.3f, test.y());

    test.move(11.1f, -33.2f);

    EXPECT_FLOAT_EQ(50.0f, test.x());
    EXPECT_FLOAT_EQ(207.1f, test.y());

    test.move(-5.6f, -9.8f);

    EXPECT_FLOAT_EQ(44.4f, test.x());
    EXPECT_FLOAT_EQ(197.3f, test.y());
}

TEST(FloatPoint, MoveByIntSize)
{
    WebCore::FloatPoint test(100.0f, 200.0f);

    EXPECT_FLOAT_EQ(100.0f, test.x());
    EXPECT_FLOAT_EQ(200.0f, test.y());

    WebCore::IntSize first(20, 30);

    test.move(first);

    EXPECT_FLOAT_EQ(120.0f, test.x());
    EXPECT_FLOAT_EQ(230.0f, test.y());

    WebCore::IntSize second(-81, 10);

    test.move(second);

    EXPECT_FLOAT_EQ(39.0f, test.x());
    EXPECT_FLOAT_EQ(240.0f, test.y());

    WebCore::IntSize third(11, -33);

    test.move(third);

    EXPECT_FLOAT_EQ(50.0f, test.x());
    EXPECT_FLOAT_EQ(207.0f, test.y());

    WebCore::IntSize fourth(-6, -10);

    test.move(fourth);

    EXPECT_FLOAT_EQ(44.0f, test.x());
    EXPECT_FLOAT_EQ(197.0f, test.y());
}

TEST(FloatPoint, MoveByFloatSize)
{
    WebCore::FloatPoint test(100.0f, 200.0f);

    EXPECT_FLOAT_EQ(100.0f, test.x());
    EXPECT_FLOAT_EQ(200.0f, test.y());

    WebCore::FloatSize first(20.2f, 30.3f);

    test.move(first);

    EXPECT_FLOAT_EQ(120.2f, test.x());
    EXPECT_FLOAT_EQ(230.3f, test.y());

    WebCore::FloatSize second(-81.3f, 10.0f);

    test.move(second);

    EXPECT_FLOAT_EQ(38.9f, test.x());
    EXPECT_FLOAT_EQ(240.3f, test.y());

    WebCore::FloatSize third(11.1f, -33.2f);

    test.move(third);

    EXPECT_FLOAT_EQ(50.0f, test.x());
    EXPECT_FLOAT_EQ(207.1f, test.y());

    WebCore::FloatSize fourth(-5.6f, -9.8f);

    test.move(fourth);

    EXPECT_FLOAT_EQ(44.4f, test.x());
    EXPECT_FLOAT_EQ(197.3f, test.y());
}

TEST(FloatPoint, MoveByIntPoint)
{
    WebCore::FloatPoint test(100.0f, 200.0f);

    EXPECT_FLOAT_EQ(100.0f, test.x());
    EXPECT_FLOAT_EQ(200.0f, test.y());

    WebCore::IntPoint first(20, 30);

    test.moveBy(first);

    EXPECT_FLOAT_EQ(120.0f, test.x());
    EXPECT_FLOAT_EQ(230.0f, test.y());

    WebCore::IntPoint second(-81, 10);

    test.moveBy(second);

    EXPECT_FLOAT_EQ(39.0f, test.x());
    EXPECT_FLOAT_EQ(240.0f, test.y());

    WebCore::IntPoint third(11, -33);

    test.moveBy(third);

    EXPECT_FLOAT_EQ(50.0f, test.x());
    EXPECT_FLOAT_EQ(207.0f, test.y());

    WebCore::IntPoint fourth(-6, -10);

    test.moveBy(fourth);

    EXPECT_FLOAT_EQ(44.0f, test.x());
    EXPECT_FLOAT_EQ(197.0f, test.y());
}

TEST(FloatPoint, MoveByFloatPoint)
{
    WebCore::FloatPoint test(100.0f, 200.0f);

    EXPECT_FLOAT_EQ(100.0f, test.x());
    EXPECT_FLOAT_EQ(200.0f, test.y());

    WebCore::FloatPoint first(20.2f, 30.3f);

    test.moveBy(first);

    EXPECT_FLOAT_EQ(120.2f, test.x());
    EXPECT_FLOAT_EQ(230.3f, test.y());

    WebCore::FloatPoint second(-81.3f, 10.0f);

    test.moveBy(second);

    EXPECT_FLOAT_EQ(38.9f, test.x());
    EXPECT_FLOAT_EQ(240.3f, test.y());

    WebCore::FloatPoint third(11.1f, -33.2f);

    test.moveBy(third);

    EXPECT_FLOAT_EQ(50.0f, test.x());
    EXPECT_FLOAT_EQ(207.1f, test.y());

    WebCore::FloatPoint fourth(-5.6f, -9.8f);

    test.moveBy(fourth);

    EXPECT_FLOAT_EQ(44.4f, test.x());
    EXPECT_FLOAT_EQ(197.3f, test.y());
}

TEST(FloatPoint, Scale)
{
    WebCore::FloatPoint test(100.0f, 200.0f);

    EXPECT_FLOAT_EQ(100.0f, test.x());
    EXPECT_FLOAT_EQ(200.0f, test.y());

    test.scale(2.0f, 2.0f);

    EXPECT_FLOAT_EQ(200.0f, test.x());
    EXPECT_FLOAT_EQ(400.0f, test.y());

    test.scale(0.5f, 0.5f);

    EXPECT_FLOAT_EQ(100.0f, test.x());
    EXPECT_FLOAT_EQ(200.0f, test.y());

    test.scale(2);

    EXPECT_FLOAT_EQ(200.0f, test.x());
    EXPECT_FLOAT_EQ(400.0f, test.y());

    test.scale(1.0f, 0.5f);

    EXPECT_FLOAT_EQ(200.0f, test.x());
    EXPECT_FLOAT_EQ(200.0f, test.y());
}

TEST(FloatPoint, Normalize)
{
    WebCore::FloatPoint a(30.0f, 40.0f);

    a.normalize();

    EXPECT_FLOAT_EQ(0.6, a.x());
    EXPECT_FLOAT_EQ(0.8, a.y());
}

TEST(FloatPoint, Dot)
{
    WebCore::FloatPoint a(100.0f, 200.0f);
    WebCore::FloatPoint b(2.0f, 4.0f);
    WebCore::FloatPoint c(1.0f, 0.5f);

    EXPECT_NEAR(1000.0f, a.dot(b), 0.0001f);
    EXPECT_NEAR(200.0f, a.dot(c), 0.0001f);
}

TEST(FloatPoint, LengthSquared)
{
    WebCore::FloatPoint test(100.0f, 200.0f);

    EXPECT_FLOAT_EQ(100.0f, test.x());
    EXPECT_FLOAT_EQ(200.0f, test.y());

    EXPECT_FLOAT_EQ(50000.0f, test.lengthSquared());
}

TEST(FloatPoint, ConstrainedBetween)
{
    WebCore::FloatPoint left(10.0f, 20.0f);
    WebCore::FloatPoint right(100.0f, 200.0f);

    WebCore::FloatPoint test1(50.0f, 80.0f);
    WebCore::FloatPoint test2(8.0f, 80.0f);
    WebCore::FloatPoint test3(50.0f, 220.0f);

    auto constrained1 = test1.constrainedBetween(left, right);
    EXPECT_FLOAT_EQ(50.0f, constrained1.x());
    EXPECT_FLOAT_EQ(80.0f, constrained1.y());

    auto constrained2 = test2.constrainedBetween(left, right);
    EXPECT_FLOAT_EQ(10.0f, constrained2.x());
    EXPECT_FLOAT_EQ(80.0f, constrained2.y());

    auto constrained3 = test3.constrainedBetween(left, right);
    EXPECT_FLOAT_EQ(50.0f, constrained3.x());
    EXPECT_FLOAT_EQ(200.0f, constrained3.y());
}

TEST(FloatPoint, ShrunkTo)
{
    WebCore::FloatPoint big(100.0f, 200.0f);
    WebCore::FloatPoint smaller(10.0f, 80.0f);

    auto shrunkTo = big.shrunkTo(smaller);

    EXPECT_FLOAT_EQ(10.0f, shrunkTo.x());
    EXPECT_FLOAT_EQ(80.0f, shrunkTo.y());

    WebCore::FloatPoint bigish(8.0f, 200.0f);

    auto shrunkTo2 = bigish.shrunkTo(smaller);

    EXPECT_FLOAT_EQ(8.0f, shrunkTo2.x());
    EXPECT_FLOAT_EQ(80.0f, shrunkTo2.y());
}

TEST(FloatPoint, ExpandedTo)
{
    WebCore::FloatPoint big(100.0f, 200.0f);
    WebCore::FloatPoint smaller(10.0f, 80.0f);

    auto expandedTo = smaller.expandedTo(big);

    EXPECT_FLOAT_EQ(100.0f, expandedTo.x());
    EXPECT_FLOAT_EQ(200.0f, expandedTo.y());

    WebCore::FloatPoint bigish(8.0f, 300.0f);

    auto expandedTo2 = bigish.expandedTo(big);

    EXPECT_FLOAT_EQ(100.0f, expandedTo2.x());
    EXPECT_FLOAT_EQ(300.0f, expandedTo2.y());
}

TEST(FloatPoint, Transpose)
{
    WebCore::FloatPoint test(100.0f, 200.0f);

    EXPECT_FLOAT_EQ(100.0f, test.x());
    EXPECT_FLOAT_EQ(200.0f, test.y());

    auto transposed = test.transposedPoint();

    EXPECT_FLOAT_EQ(200.0f, transposed.x());
    EXPECT_FLOAT_EQ(100.0f, transposed.y());
}

TEST(FloatPoint, Transforms)
{
    WebCore::FloatPoint test(100.0f, 200.0f);

    WebCore::AffineTransform affine;

    auto transformed1 = test.matrixTransform(affine);

    EXPECT_FLOAT_EQ(100.0f, transformed1.x());
    EXPECT_FLOAT_EQ(200.0f, transformed1.y());

    WebCore::AffineTransform affine2(2.0, 0.0, 0.0, 2.0, 0.0, 0.0);

    auto transformed2 = test.matrixTransform(affine2);

    EXPECT_FLOAT_EQ(200.0f, transformed2.x());
    EXPECT_FLOAT_EQ(400.0f, transformed2.y());

    WebCore::TransformationMatrix matrix;

    auto transformed3 = test.matrixTransform(matrix);

    EXPECT_FLOAT_EQ(100.0f, transformed3.x());
    EXPECT_FLOAT_EQ(200.0f, transformed3.y());

    auto transformed4 = test.matrixTransform(affine2.toTransformationMatrix());

    EXPECT_FLOAT_EQ(200.0f, transformed4.x());
    EXPECT_FLOAT_EQ(400.0f, transformed4.y());
}

TEST(FloatPoint, Math)
{
    WebCore::FloatPoint a(100.0f, 200.0f);
    WebCore::FloatPoint b(100.0f, 200.0f);

    a += b;

    EXPECT_FLOAT_EQ(200.0f, a.x());
    EXPECT_FLOAT_EQ(400.0f, a.y());

    WebCore::FloatSize c(50.0f, 50.0f);

    a += c;

    EXPECT_FLOAT_EQ(250.0f, a.x());
    EXPECT_FLOAT_EQ(450.0f, a.y());

    WebCore::FloatSize d(10.0f, 200.0f);

    a -= d;

    EXPECT_FLOAT_EQ(240.0f, a.x());
    EXPECT_FLOAT_EQ(250.0f, a.y());

    WebCore::FloatSize e(100.0f, 200.0f);

    auto f = b + e;

    EXPECT_FLOAT_EQ(200.0f, f.x());
    EXPECT_FLOAT_EQ(400.0f, f.y());

    WebCore::FloatPoint g(10.0f, 20.0f);

    auto h = b + g;

    EXPECT_FLOAT_EQ(110.0f, h.x());
    EXPECT_FLOAT_EQ(220.0f, h.y());

    WebCore::FloatSize i = b - g;

    EXPECT_FLOAT_EQ(90.0f, i.width());
    EXPECT_FLOAT_EQ(180.0f, i.height());

    WebCore::FloatPoint j = b - e;

    EXPECT_FLOAT_EQ(0.0f, j.x());
    EXPECT_FLOAT_EQ(0.0f, j.y());

    WebCore::FloatPoint negated = -b;

    EXPECT_FLOAT_EQ(-100.0f, negated.x());
    EXPECT_FLOAT_EQ(-200.0f, negated.y());

    float value = b * g;

    EXPECT_FLOAT_EQ(5000.0f, value);
}

TEST(FloatPoint, Equality)
{
    WebCore::FloatPoint a(100.0f, 200.0f);
    WebCore::FloatPoint b(100.0f, 200.0f);
    WebCore::FloatPoint c(10.0f, 20.0f);

    ASSERT_TRUE(a == b);
    ASSERT_FALSE(a == c);
    ASSERT_FALSE(a != b);
    ASSERT_TRUE(a != c);

    ASSERT_TRUE(WebCore::areEssentiallyEqual(a, b));
    ASSERT_FALSE(WebCore::areEssentiallyEqual(a, c));
}

TEST(FloatPoint, Floors)
{
    WebCore::FloatPoint a(100.6f, 199.9f);

    WebCore::IntSize flooredSize = WebCore::flooredIntSize(a);
    EXPECT_FLOAT_EQ(100, flooredSize.width());
    EXPECT_FLOAT_EQ(199, flooredSize.height());

    WebCore::IntPoint flooredPoint = WebCore::flooredIntPoint(a);
    EXPECT_FLOAT_EQ(100, flooredPoint.x());
    EXPECT_FLOAT_EQ(199, flooredPoint.y());

    WebCore::FloatPoint flooredPoint1x = WebCore::floorPointToDevicePixels(a, 1.0);
    EXPECT_FLOAT_EQ(100.0f, flooredPoint1x.x());
    EXPECT_FLOAT_EQ(199.0f, flooredPoint1x.y());

    WebCore::FloatPoint flooredPoint2x = WebCore::floorPointToDevicePixels(a, 2.0);
    EXPECT_FLOAT_EQ(100.5f, flooredPoint2x.x());
    EXPECT_FLOAT_EQ(199.5f, flooredPoint2x.y());
}

TEST(FloatPoint, Rounding)
{
    WebCore::FloatPoint a(100.4f, 199.9f);

    WebCore::IntPoint roundedPoint = WebCore::roundedIntPoint(a);
    EXPECT_FLOAT_EQ(100, roundedPoint.x());
    EXPECT_FLOAT_EQ(200, roundedPoint.y());
}

TEST(FloatPoint, Ceiling)
{
    WebCore::FloatPoint a(100.4f, 199.9f);

    WebCore::IntPoint ceilingPoint = WebCore::ceiledIntPoint(a);
    EXPECT_FLOAT_EQ(101, ceilingPoint.x());
    EXPECT_FLOAT_EQ(200, ceilingPoint.y());

    WebCore::FloatPoint ceilingPoint1x = WebCore::ceilPointToDevicePixels(a, 1.0);
    EXPECT_FLOAT_EQ(101.0f, ceilingPoint1x.x());
    EXPECT_FLOAT_EQ(200.0f, ceilingPoint1x.y());

    WebCore::FloatPoint ceilingPoint2x = WebCore::ceilPointToDevicePixels(a, 2.0);
    EXPECT_FLOAT_EQ(100.5f, ceilingPoint2x.x());
    EXPECT_FLOAT_EQ(200.0f, ceilingPoint2x.y());
}

TEST(FloatPoint, Casting)
{
    WebCore::FloatPoint a(100.4f, 199.9f);

    WebCore::FloatSize floatSize = WebCore::toFloatSize(a);
    EXPECT_FLOAT_EQ(100.4f, floatSize.width());
    EXPECT_FLOAT_EQ(199.9f, floatSize.height());

    WebCore::FloatSize b(99.6f, 299.1f);

    WebCore::FloatPoint floatPoint = WebCore::toFloatPoint(b);
    EXPECT_FLOAT_EQ(99.6f, floatPoint.x());
    EXPECT_FLOAT_EQ(299.1f, floatPoint.y());

#if USE(CG)
    CGPoint cgPoint = a;

    EXPECT_FLOAT_EQ(100.4f, cgPoint.x);
    EXPECT_FLOAT_EQ(199.9f, cgPoint.y);

    CGPoint cgPoint2 = CGPointMake(-22.3f, 14.2f);

    WebCore::FloatPoint testCG(cgPoint2);

    EXPECT_FLOAT_EQ(-22.3f, testCG.x());
    EXPECT_FLOAT_EQ(14.2f, testCG.y());
#endif

#if PLATFORM(WIN)
    D2D_POINT_2F d2dPoint = a;

    EXPECT_FLOAT_EQ(100.4f, d2dPoint.x);
    EXPECT_FLOAT_EQ(199.9f, d2dPoint.y);

    D2D_POINT_2F d2dPoint2 = D2D1::Point2F(-22.3f, 14.2f);

    WebCore::FloatPoint testD2D(d2dPoint2);

    EXPECT_FLOAT_EQ(-22.3f, testD2D.x());
    EXPECT_FLOAT_EQ(14.2f, testD2D.y());
#endif
}

}