// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/accessibility/platform/inspect/ax_tree_formatter_mac.h"

#include <string>

#include "base/files/file_path.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/strings/sys_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "ui/accessibility/platform/ax_platform_node_cocoa.h"
#include "ui/accessibility/platform/inspect/ax_element_wrapper_mac.h"
#include "ui/accessibility/platform/inspect/ax_inspect_scenario.h"
#include "ui/accessibility/platform/inspect/ax_inspect_utils.h"
#include "ui/accessibility/platform/inspect/ax_inspect_utils_mac.h"
#include "ui/accessibility/platform/inspect/ax_property_node.h"
#include "ui/accessibility/platform/inspect/ax_script_instruction.h"
#include "ui/accessibility/platform/inspect/ax_transform_mac.h"
#include "ui/gfx/native_widget_types.h"

// TODO(https://crbug.com/406190900): Remove this deprecation pragma.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"

namespace ui {

namespace {

constexpr char kLocalPositionDictAttr[] = "LocalPosition";

constexpr char kFailedPrefix[] = "_const_ERROR:";
constexpr char kFailedToParseError[] = "_const_ERROR:FAILED_TO_PARSE";
constexpr char kNotApplicable[] = "_const_n/a";

}  // namespace

AXTreeFormatterMac::AXTreeFormatterMac() = default;

AXTreeFormatterMac::~AXTreeFormatterMac() = default;

void AXTreeFormatterMac::AddDefaultFilters(
    std::vector<AXPropertyFilter>* property_filters) {
  static NSArray* default_attributes = @[
    @"AXAutocompleteValue", @"AXDescription", @"AXRole", @"AXSubrole",
    @"AXTitle", @"AXTitleUIElement", @"AXValue"
  ];

  for (NSString* attribute : default_attributes) {
    AddPropertyFilter(property_filters, base::SysNSStringToUTF8(attribute));
  }

  if (show_ids()) {
    AddPropertyFilter(property_filters, "ChromeAXNodeId");
  }
}

base::Value::Dict AXTreeFormatterMac::BuildTree(
    AXPlatformNodeDelegate* root) const {
  DCHECK(root);
  return BuildTree(root->GetNativeViewAccessible().Get());
}

base::Value::Dict AXTreeFormatterMac::BuildTreeForSelector(
    const AXTreeSelector& selector) const {
  base::apple::ScopedCFTypeRef<AXUIElementRef> node;
  std::tie(node, std::ignore) = FindAXUIElement(selector);
  if (!node) {
    return base::Value::Dict();
  }
  return BuildTreeForAXUIElement(node.get());
}

base::Value::Dict AXTreeFormatterMac::BuildTreeForAXUIElement(
    AXUIElementRef node) const {
  return BuildTree((__bridge id)node);
}

base::Value::Dict AXTreeFormatterMac::BuildTree(id root) const {
  DCHECK(root);

  AXTreeIndexerMac indexer((gfx::NativeViewAccessible(root)));
  base::Value::Dict dict;

  AXElementWrapper ax_element(root);
  NSPoint position = ax_element.Position();
  NSSize size = ax_element.Size();
  NSRect rect = NSMakeRect(position.x, position.y, size.width, size.height);

  RecursiveBuildTree(ax_element, rect, &indexer, &dict);

  return dict;
}

std::string AXTreeFormatterMac::EvaluateScript(
    const AXTreeSelector& selector,
    const AXInspectScenario& scenario) const {
  base::apple::ScopedCFTypeRef<AXUIElementRef> root;
  std::tie(root, std::ignore) = FindAXUIElement(selector);
  if (!root)
    return "";

  std::string result =
      EvaluateScript((__bridge id)root.get(), scenario.script_instructions, 0,
                     scenario.script_instructions.size());

  return result;
}

std::string AXTreeFormatterMac::EvaluateScript(
    AXPlatformNodeDelegate* root,
    const std::vector<AXScriptInstruction>& instructions,
    size_t start_index,
    size_t end_index) const {
  return EvaluateScript(root->GetNativeViewAccessible().Get(), instructions,
                        start_index, end_index);
}

std::string AXTreeFormatterMac::EvaluateScript(
    id platform_root,
    const std::vector<AXScriptInstruction>& instructions,
    size_t start_index,
    size_t end_index) const {
  base::Value::List scripts;
  AXTreeIndexerMac indexer((gfx::NativeViewAccessible(platform_root)));
  std::map<std::string, id> storage;
  AXCallStatementInvoker invoker(&indexer, &storage);
  for (size_t index = start_index; index < end_index; index++) {
    if (instructions[index].IsComment()) {
      scripts.Append(instructions[index].AsComment());
      continue;
    }

    DCHECK(instructions[index].IsScript());
    const AXPropertyNode& property_node = instructions[index].AsScript();
    AXOptionalNSObject value = invoker.Invoke(property_node);
    if (value.IsUnsupported()) {
      continue;
    }

    base::Value result;
    if (value.IsError()) {
      result = value.HasStateText()
                   ? base::Value(kFailedPrefix + value.StateText())
                   : base::Value(kFailedToParseError);
    } else if (value.IsNotApplicable()) {
      result = base::Value(kNotApplicable);
    } else {
      result = AXNSObjectToBaseValue(*value, &indexer);
    }

    scripts.Append(property_node.ToString() + "=" + AXFormatValue(result));
  }

  std::string contents;
  for (const base::Value& script : scripts) {
    std::string line;
    WriteAttribute(true, script.GetString(), &line);
    contents += line + "\n";
  }
  return contents;
}

base::Value::Dict AXTreeFormatterMac::BuildNode(
    AXPlatformNodeDelegate* node) const {
  DCHECK(node);
  return BuildNode(node->GetNativeViewAccessible());
}

base::Value::Dict AXTreeFormatterMac::BuildNodeForSelector(
    const AXTreeSelector& selector) const {
  base::apple::ScopedCFTypeRef<AXUIElementRef> node;
  std::tie(node, std::ignore) = FindAXUIElement(selector);
  if (!node) {
    return base::Value::Dict();
  }
  return BuildNode(gfx::NativeViewAccessible((__bridge id)node.get()));
}

base::Value::Dict AXTreeFormatterMac::BuildNode(
    gfx::NativeViewAccessible node) const {
  DCHECK(node);

  AXTreeIndexerMac indexer(node);
  base::Value::Dict dict;

  AXElementWrapper ax_element(node.Get());
  NSPoint position = ax_element.Position();
  NSSize size = ax_element.Size();
  NSRect rect = NSMakeRect(position.x, position.y, size.width, size.height);

  AddProperties(ax_element, rect, &indexer, &dict);
  return dict;
}

void AXTreeFormatterMac::RecursiveBuildTree(const AXElementWrapper& ax_element,
                                            const NSRect& root_rect,
                                            const AXTreeIndexerMac* indexer,
                                            base::Value::Dict* dict) const {
  AXPlatformNodeDelegate* platform_node = ax_element.IsNSAccessibilityElement()
                                              ? [ax_element.AsId() nodeDelegate]
                                              : nullptr;

  if (platform_node && !ShouldDumpNode(*platform_node))
    return;

  AddProperties(ax_element, root_rect, indexer, dict);
  if (platform_node && !ShouldDumpChildren(*platform_node))
    return;

  NSArray* children = ax_element.Children();
  base::Value::List child_dict_list;
  for (id child in children) {
    base::Value::Dict child_dict;
    RecursiveBuildTree(AXElementWrapper{child}, root_rect, indexer,
                       &child_dict);
    child_dict_list.Append(std::move(child_dict));
  }
  dict->Set(kChildrenDictAttr, std::move(child_dict_list));
}

void AXTreeFormatterMac::AddProperties(const AXElementWrapper& ax_element,
                                       const NSRect& root_rect,
                                       const AXTreeIndexerMac* indexer,
                                       base::Value::Dict* dict) const {
  // Chromium special attributes.
  dict->Set(kLocalPositionDictAttr,
            PopulateLocalPosition(ax_element, root_rect));

  // Dump all attributes if match-all filter is specified.
  if (HasMatchAllPropertyFilter()) {
    NSArray* attributes = ax_element.AttributeNames();
    for (NSString* attribute : attributes) {
      dict->SetByDottedPath(
          base::SysNSStringToUTF8(attribute),
          AXNSObjectToBaseValue(*ax_element.GetAttributeValue(attribute),
                                indexer));
    }
    return;
  }

  // Otherwise dump attributes matching allow filters only.
  std::string line_index =
      indexer->IndexBy(gfx::NativeViewAccessible(ax_element.AsId()));
  for (const AXPropertyNode& property_node :
       PropertyFilterNodesFor(line_index)) {
    AXCallStatementInvoker invoker(ax_element.AsId(), indexer);
    AXOptionalNSObject value = invoker.Invoke(property_node);
    if (value.IsNotApplicable() || value.IsUnsupported()) {
      continue;
    }
    if (value.IsError()) {
      dict->SetByDottedPath(property_node.original_property,
                            base::Value(kFailedToParseError));
      continue;
    }
    dict->SetByDottedPath(property_node.original_property,
                          AXNSObjectToBaseValue(*value, indexer));
  }
}

base::Value::Dict AXTreeFormatterMac::PopulateLocalPosition(
    const AXElementWrapper& ax_element,
    const NSRect& root_rect) const {
  // The NSAccessibility position of an object is in global coordinates and
  // based on the lower-left corner of the object. To make this easier and
  // less confusing, convert it to local window coordinates using the top-left
  // corner when dumping the position.
  int root_top = -static_cast<int>(root_rect.origin.y + root_rect.size.height);
  int root_left = static_cast<int>(root_rect.origin.x);

  NSPoint node_position = ax_element.Position();
  NSSize node_size = ax_element.Size();

  return AXNSPointToBaseValue(NSMakePoint(
      static_cast<int>(node_position.x - root_left),
      static_cast<int>(-node_position.y - node_size.height - root_top)));
}

std::string AXTreeFormatterMac::ProcessTreeForOutput(
    const base::Value::Dict& dict) const {
  const std::string* error_value = dict.FindString("error");
  if (error_value)
    return *error_value;

  std::string line;

  // AXRole and AXSubrole have own formatting and should be listed upfront.
  std::string role_attr = base::SysNSStringToUTF8(NSAccessibilityRoleAttribute);
  const std::string* value = dict.FindString(role_attr);
  if (value) {
    WriteAttribute(true, *value, &line);
  }
  std::string subrole_attr =
      base::SysNSStringToUTF8(NSAccessibilitySubroleAttribute);
  value = dict.FindString(subrole_attr);
  if (value) {
    WriteAttribute(
        false,
        base::StringPrintf("%s=%s", subrole_attr.c_str(), value->c_str()),
        &line);
  }

  // Expose all other attributes.
  for (auto item : dict) {
    if (item.second.is_string() &&
        (item.first == role_attr || item.first == subrole_attr)) {
      continue;
    }

    // Special case: children.
    // Children are used to generate the tree
    // itself, thus no sense to expose them on each node.
    if (item.first == kChildrenDictAttr) {
      continue;
    }

    // Write formatted value.
    std::string formatted_value = AXFormatValue(item.second);
    WriteAttribute(false,
                   base::StringPrintf("%s=%s", item.first.c_str(),
                                      formatted_value.c_str()),
                   &line);
  }

  return line;
}

}  // namespace ui

#pragma clang diagnostic pop