/*
 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
 *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
 * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
 * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc.
 * All rights reserved.
 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
 * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
 * (http://www.torchmobile.com/)
 * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
 * Copyright (C) Research In Motion Limited 2011. All rights reserved.
 * Copyright (C) 2012 Google Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "third_party/blink/renderer/core/css/resolver/transform_builder.h"

#include "third_party/blink/renderer/core/css/css_function_value.h"
#include "third_party/blink/renderer/core/css/css_math_expression_node.h"
#include "third_party/blink/renderer/core/css/css_math_function_value.h"
#include "third_party/blink/renderer/core/css/css_numeric_literal_value.h"
#include "third_party/blink/renderer/core/css/css_primitive_value_mappings.h"
#include "third_party/blink/renderer/platform/heap/handle.h"
#include "third_party/blink/renderer/platform/transforms/matrix_3d_transform_operation.h"
#include "third_party/blink/renderer/platform/transforms/matrix_transform_operation.h"
#include "third_party/blink/renderer/platform/transforms/perspective_transform_operation.h"
#include "third_party/blink/renderer/platform/transforms/rotate_transform_operation.h"
#include "third_party/blink/renderer/platform/transforms/scale_transform_operation.h"
#include "third_party/blink/renderer/platform/transforms/skew_transform_operation.h"
#include "third_party/blink/renderer/platform/transforms/transformation_matrix.h"
#include "third_party/blink/renderer/platform/transforms/translate_transform_operation.h"

namespace blink {

static Length ConvertToFloatLength(
    const CSSPrimitiveValue& primitive_value,
    const CSSToLengthConversionData& conversion_data) {
  return primitive_value.ConvertToLength(conversion_data);
}

static TransformOperation::OperationType GetTransformOperationType(
    CSSValueID type) {
  switch (type) {
    default:
      NOTREACHED();
      FALLTHROUGH;
    case CSSValueID::kScale:
      return TransformOperation::kScale;
    case CSSValueID::kScaleX:
      return TransformOperation::kScaleX;
    case CSSValueID::kScaleY:
      return TransformOperation::kScaleY;
    case CSSValueID::kScaleZ:
      return TransformOperation::kScaleZ;
    case CSSValueID::kScale3d:
      return TransformOperation::kScale3D;
    case CSSValueID::kTranslate:
      return TransformOperation::kTranslate;
    case CSSValueID::kTranslateX:
      return TransformOperation::kTranslateX;
    case CSSValueID::kTranslateY:
      return TransformOperation::kTranslateY;
    case CSSValueID::kTranslateZ:
      return TransformOperation::kTranslateZ;
    case CSSValueID::kTranslate3d:
      return TransformOperation::kTranslate3D;
    case CSSValueID::kRotate:
      return TransformOperation::kRotate;
    case CSSValueID::kRotateX:
      return TransformOperation::kRotateX;
    case CSSValueID::kRotateY:
      return TransformOperation::kRotateY;
    case CSSValueID::kRotateZ:
      return TransformOperation::kRotateZ;
    case CSSValueID::kRotate3d:
      return TransformOperation::kRotate3D;
    case CSSValueID::kSkew:
      return TransformOperation::kSkew;
    case CSSValueID::kSkewX:
      return TransformOperation::kSkewX;
    case CSSValueID::kSkewY:
      return TransformOperation::kSkewY;
    case CSSValueID::kMatrix:
      return TransformOperation::kMatrix;
    case CSSValueID::kMatrix3d:
      return TransformOperation::kMatrix3D;
    case CSSValueID::kPerspective:
      return TransformOperation::kPerspective;
  }
}

bool TransformBuilder::HasRelativeLengths(const CSSValueList& value_list) {
  for (auto& value : value_list) {
    const auto* transform_value = To<CSSFunctionValue>(value.Get());

    for (const CSSValue* item : *transform_value) {
      const auto& primitive_value = To<CSSPrimitiveValue>(*item);
      if (primitive_value.IsCalculated()) {
        if (To<CSSMathFunctionValue>(primitive_value).MayHaveRelativeUnit())
          return true;
      } else {
        CSSPrimitiveValue::UnitType unit_type =
            To<CSSNumericLiteralValue>(primitive_value).GetType();
        if (CSSPrimitiveValue::IsRelativeUnit(unit_type))
          return true;
      }
    }
  }
  return false;
}

TransformOperations TransformBuilder::CreateTransformOperations(
    const CSSValue& in_value,
    const CSSToLengthConversionData& conversion_data) {
  TransformOperations operations;
  auto* in_value_list = DynamicTo<CSSValueList>(in_value);
  if (!in_value_list) {
    DCHECK_EQ(To<CSSIdentifierValue>(in_value).GetValueID(), CSSValueID::kNone);
    return operations;
  }

  float zoom_factor = conversion_data.Zoom();
  for (auto& value : *in_value_list) {
    const auto* transform_value = To<CSSFunctionValue>(value.Get());
    TransformOperation::OperationType transform_type =
        GetTransformOperationType(transform_value->FunctionType());

    const auto& first_value = To<CSSPrimitiveValue>(transform_value->Item(0));

    switch (transform_type) {
      case TransformOperation::kScale:
      case TransformOperation::kScaleX:
      case TransformOperation::kScaleY: {
        double sx = 1.0;
        double sy = 1.0;
        if (transform_type == TransformOperation::kScaleY) {
          sy = first_value.GetDoubleValue();
        } else {
          sx = first_value.GetDoubleValue();
          if (transform_type != TransformOperation::kScaleX) {
            if (transform_value->length() > 1) {
              const auto& second_value =
                  To<CSSPrimitiveValue>(transform_value->Item(1));
              sy = second_value.GetDoubleValue();
            } else {
              sy = sx;
            }
          }
        }
        operations.Operations().push_back(
            ScaleTransformOperation::Create(sx, sy, 1.0, transform_type));
        break;
      }
      case TransformOperation::kScaleZ:
      case TransformOperation::kScale3D: {
        double sx = 1.0;
        double sy = 1.0;
        double sz = 1.0;
        if (transform_type == TransformOperation::kScaleZ) {
          sz = first_value.GetDoubleValue();
        } else {
          sx = first_value.GetDoubleValue();
          sy = To<CSSPrimitiveValue>(transform_value->Item(1)).GetDoubleValue();
          sz = To<CSSPrimitiveValue>(transform_value->Item(2)).GetDoubleValue();
        }
        operations.Operations().push_back(
            ScaleTransformOperation::Create(sx, sy, sz, transform_type));
        break;
      }
      case TransformOperation::kTranslate:
      case TransformOperation::kTranslateX:
      case TransformOperation::kTranslateY: {
        Length tx = Length::Fixed(0);
        Length ty = Length::Fixed(0);
        if (transform_type == TransformOperation::kTranslateY)
          ty = ConvertToFloatLength(first_value, conversion_data);
        else {
          tx = ConvertToFloatLength(first_value, conversion_data);
          if (transform_type != TransformOperation::kTranslateX) {
            if (transform_value->length() > 1) {
              const auto& second_value =
                  To<CSSPrimitiveValue>(transform_value->Item(1));
              ty = ConvertToFloatLength(second_value, conversion_data);
            }
          }
        }

        operations.Operations().push_back(
            TranslateTransformOperation::Create(tx, ty, 0, transform_type));
        break;
      }
      case TransformOperation::kTranslateZ:
      case TransformOperation::kTranslate3D: {
        Length tx = Length::Fixed(0);
        Length ty = Length::Fixed(0);
        double tz = 0;
        if (transform_type == TransformOperation::kTranslateZ) {
          tz = first_value.ComputeLength<double>(conversion_data);
        } else {
          tx = ConvertToFloatLength(first_value, conversion_data);
          ty = ConvertToFloatLength(
              To<CSSPrimitiveValue>(transform_value->Item(1)), conversion_data);
          tz = To<CSSPrimitiveValue>(transform_value->Item(2))
                   .ComputeLength<double>(conversion_data);
        }

        operations.Operations().push_back(
            TranslateTransformOperation::Create(tx, ty, tz, transform_type));
        break;
      }
      case TransformOperation::kRotateX:
      case TransformOperation::kRotateY:
      case TransformOperation::kRotateZ: {
        double angle = first_value.ComputeDegrees();
        if (transform_value->length() == 1) {
          double x = transform_type == TransformOperation::kRotateX;
          double y = transform_type == TransformOperation::kRotateY;
          double z = transform_type == TransformOperation::kRotateZ;
          operations.Operations().push_back(
              RotateTransformOperation::Create(x, y, z, angle, transform_type));
        } else {
          // For SVG 'transform' attributes we generate 3-argument rotate()
          // functions.
          DCHECK_EQ(transform_value->length(), 3u);
          const auto& second_value =
              To<CSSPrimitiveValue>(transform_value->Item(1));
          const CSSPrimitiveValue& third_value =
              To<CSSPrimitiveValue>(transform_value->Item(2));
          operations.Operations().push_back(
              RotateAroundOriginTransformOperation::Create(
                  angle, second_value.ComputeLength<double>(conversion_data),
                  third_value.ComputeLength<double>(conversion_data)));
        }
        break;
      }
      case TransformOperation::kRotate3D: {
        const auto& second_value =
            To<CSSPrimitiveValue>(transform_value->Item(1));
        const auto& third_value =
            To<CSSPrimitiveValue>(transform_value->Item(2));
        const auto& fourth_value =
            To<CSSPrimitiveValue>(transform_value->Item(3));
        double x = first_value.GetDoubleValue();
        double y = second_value.GetDoubleValue();
        double z = third_value.GetDoubleValue();
        double angle = fourth_value.ComputeDegrees();
        operations.Operations().push_back(
            RotateTransformOperation::Create(x, y, z, angle, transform_type));
        break;
      }
      case TransformOperation::kSkew:
      case TransformOperation::kSkewX:
      case TransformOperation::kSkewY: {
        double angle_x = 0;
        double angle_y = 0;
        double angle = first_value.ComputeDegrees();
        if (transform_type == TransformOperation::kSkewY)
          angle_y = angle;
        else {
          angle_x = angle;
          if (transform_type == TransformOperation::kSkew) {
            if (transform_value->length() > 1) {
              const auto& second_value =
                  To<CSSPrimitiveValue>(transform_value->Item(1));
              angle_y = second_value.ComputeDegrees();
            }
          }
        }
        operations.Operations().push_back(
            SkewTransformOperation::Create(angle_x, angle_y, transform_type));
        break;
      }
      case TransformOperation::kMatrix: {
        double a = first_value.GetDoubleValue();
        double b =
            To<CSSPrimitiveValue>(transform_value->Item(1)).GetDoubleValue();
        double c =
            To<CSSPrimitiveValue>(transform_value->Item(2)).GetDoubleValue();
        double d =
            To<CSSPrimitiveValue>(transform_value->Item(3)).GetDoubleValue();
        double e =
            zoom_factor *
            To<CSSPrimitiveValue>(transform_value->Item(4)).GetDoubleValue();
        double f =
            zoom_factor *
            To<CSSPrimitiveValue>(transform_value->Item(5)).GetDoubleValue();
        operations.Operations().push_back(
            MatrixTransformOperation::Create(a, b, c, d, e, f));
        break;
      }
      case TransformOperation::kMatrix3D: {
        TransformationMatrix matrix(
            To<CSSPrimitiveValue>(transform_value->Item(0)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(1)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(2)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(3)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(4)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(5)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(6)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(7)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(8)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(9)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(10)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(11)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(12)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(13)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(14)).GetDoubleValue(),
            To<CSSPrimitiveValue>(transform_value->Item(15)).GetDoubleValue());
        matrix.Zoom(zoom_factor);
        operations.Operations().push_back(
            Matrix3DTransformOperation::Create(matrix));
        break;
      }
      case TransformOperation::kPerspective: {
        double p = first_value.ComputeLength<double>(conversion_data);
        DCHECK_GE(p, 0);
        operations.Operations().push_back(
            PerspectiveTransformOperation::Create(p));
        break;
      }
      default:
        NOTREACHED();
        break;
    }
  }
  return operations;
}

}  // namespace blink