// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/ui/tools/print-input-report/devices.h"

#include <fidl/fuchsia.input.report/cpp/wire.h>
#include <lib/ddk/device.h>
#include <lib/trace/event.h>
#include <zircon/status.h>

namespace print_input_report {

zx_status_t PrintFeatureReports(std::string filename, Printer* printer,
                                fidl::WireSharedClient<fuchsia_input_report::InputDevice> client,
                                fit::closure callback) {
  client->GetFeatureReport().ThenExactlyOnce(
      [filename = std::move(filename), printer, callback = std::move(callback), _ = client.Clone()](
          fidl::WireUnownedResult<fuchsia_input_report::InputDevice::GetFeatureReport>&
              call_result) {
        if (!call_result.ok()) {
          return;
        }
        auto* result = call_result.Unwrap();
        if (result->is_error()) {
          callback();
          return;
        }
        auto& report = result->value()->report;

        printer->SetIndent(0);
        printer->Print("Feature Report from file: %s\n", filename.c_str());
        printer->IncreaseIndent();
        if (report.has_sensor()) {
          printer->Print("Sensor Feature Report:\n");
          printer->IncreaseIndent();
          if (report.sensor().has_report_interval()) {
            printer->Print("Report Interval: %ld\n", report.sensor().report_interval());
          }
          if (report.sensor().has_reporting_state()) {
            printer->Print("Reporting State: %u\n", report.sensor().reporting_state());
          }
          if (report.sensor().has_sensitivity()) {
            printer->Print("Sensitivity:\n");
            printer->IncreaseIndent();
            for (size_t i = 0; i < report.sensor().sensitivity().count(); i++) {
              printer->Print("%ld ", report.sensor().sensitivity().data()[i]);
            }
            printer->Print("\n");
            printer->DecreaseIndent();
          }
          if (report.sensor().has_threshold_high()) {
            printer->Print("Threshold High:\n");
            printer->IncreaseIndent();
            for (size_t i = 0; i < report.sensor().threshold_high().count(); i++) {
              printer->Print("%ld ", report.sensor().threshold_high().data()[i]);
            }
            printer->Print("\n");
            printer->DecreaseIndent();
          }
          if (report.sensor().has_threshold_low()) {
            printer->Print("Threshold Low:\n");
            printer->IncreaseIndent();
            for (size_t i = 0; i < report.sensor().threshold_low().count(); i++) {
              printer->Print("%ld ", report.sensor().threshold_low().data()[i]);
            }
            printer->Print("\n");
            printer->DecreaseIndent();
          }
          if (report.sensor().has_sampling_rate()) {
            printer->Print("Sampling Rate: %u\n", report.sensor().sampling_rate());
          }
          printer->DecreaseIndent();
        }

        if (report.has_touch()) {
          printer->Print("Touch Feature Report:\n");
          printer->IncreaseIndent();
          if (report.touch().has_input_mode()) {
            printer->Print("Input Mode: %u\n", report.touch().input_mode());
          }
          if (report.touch().has_selective_reporting()) {
            printer->Print("Selective Reporting:\n");
            printer->IncreaseIndent();
            if (report.touch().selective_reporting().has_surface_switch()) {
              printer->Print("Surface Switch: %u\n",
                             report.touch().selective_reporting().surface_switch());
            }
            if (report.touch().selective_reporting().has_button_switch()) {
              printer->Print("Button Switch: %u\n",
                             report.touch().selective_reporting().button_switch());
            }
            printer->DecreaseIndent();
          }
          printer->DecreaseIndent();
        }
        printer->DecreaseIndent();
        callback();
      });
  return ZX_OK;
}

zx_status_t PrintInputDescriptor(std::string filename, Printer* printer,
                                 fidl::WireSharedClient<fuchsia_input_report::InputDevice> client,
                                 fit::closure callback) {
  client->GetDescriptor().ThenExactlyOnce(
      [filename = std::move(filename), printer, callback = std::move(callback), _ = client.Clone()](
          fidl::WireUnownedResult<fuchsia_input_report::InputDevice::GetDescriptor>& call_result) {
        if (!call_result.ok()) {
          return;
        }
        auto* result = call_result.Unwrap();
        printer->SetIndent(0);
        printer->Print("Descriptor from file: %s\n", filename.c_str());
        if (result->descriptor.has_device_information()) {
          PrintDeviceInfo(printer, result->descriptor.device_information());
        }
        if (result->descriptor.has_mouse()) {
          if (result->descriptor.mouse().has_input()) {
            PrintMouseDesc(printer, result->descriptor.mouse().input());
          }
        }
        if (result->descriptor.has_sensor()) {
          if (result->descriptor.sensor().has_input()) {
            for (const auto& input : result->descriptor.sensor().input()) {
              PrintSensorDesc(printer, input);
            }
          }
        }
        if (result->descriptor.has_touch()) {
          PrintTouchDesc(printer, result->descriptor.touch());
        }
        if (result->descriptor.has_keyboard()) {
          PrintKeyboardDesc(printer, result->descriptor.keyboard());
        }
        if (result->descriptor.has_consumer_control()) {
          PrintConsumerControlDesc(printer, result->descriptor.consumer_control());
        }
        callback();
      });
  return ZX_OK;
}

void PrintDeviceInfo(Printer* printer,
                     const fuchsia_input_report::wire::DeviceInformation& device_info) {
  printer->Print("Device Info:\n");
  printer->IncreaseIndent();

  printer->Print("Vendor ID:\n");
  printer->IncreaseIndent();
  printer->Print("0x%x\n", device_info.vendor_id());
  printer->DecreaseIndent();

  printer->Print("Product ID:\n");
  printer->IncreaseIndent();
  printer->Print("0x%x\n", device_info.product_id());
  printer->DecreaseIndent();

  printer->Print("Version:\n");
  printer->IncreaseIndent();
  printer->Print("0x%x\n", device_info.version());
  printer->DecreaseIndent();

  printer->Print("Polling Rate:\n");
  printer->IncreaseIndent();
  printer->Print("%lu usec\n", device_info.polling_rate());
  printer->DecreaseIndent();

  printer->DecreaseIndent();
}

void PrintMouseDesc(Printer* printer,
                    const fuchsia_input_report::wire::MouseInputDescriptor& mouse_desc) {
  printer->Print("Mouse Descriptor:\n");
  printer->IncreaseIndent();
  if (mouse_desc.has_movement_x()) {
    printer->Print("Movement X:\n");
    printer->PrintAxisIndented(mouse_desc.movement_x());
  }
  if (mouse_desc.has_movement_y()) {
    printer->Print("Movement Y:\n");
    printer->PrintAxisIndented(mouse_desc.movement_y());
  }
  if (mouse_desc.has_position_x()) {
    printer->Print("Position X:\n");
    printer->PrintAxisIndented(mouse_desc.position_x());
  }
  if (mouse_desc.has_position_y()) {
    printer->Print("Position Y:\n");
    printer->PrintAxisIndented(mouse_desc.position_y());
  }
  if (mouse_desc.has_buttons()) {
    for (uint8_t button : mouse_desc.buttons()) {
      printer->Print("Button: %d\n", button);
    }
  }
  printer->DecreaseIndent();
}

void PrintSensorDesc(Printer* printer,
                     const fuchsia_input_report::wire::SensorInputDescriptor& sensor_desc) {
  printer->Print("Sensor Descriptor:\n");
  if (!sensor_desc.has_values()) {
    return;
  }

  printer->IncreaseIndent();
  if (sensor_desc.has_report_id()) {
    printer->Print("ReportID: %02d\n", sensor_desc.report_id());
  }
  for (size_t i = 0; i < sensor_desc.values().count(); i++) {
    printer->Print("Value %02d:\n", i);
    printer->IncreaseIndent();
    printer->Print("SensorType: %s\n", Printer::SensorTypeToString(sensor_desc.values()[i].type));
    printer->PrintAxis(sensor_desc.values()[i].axis);
    printer->DecreaseIndent();
  }
  printer->DecreaseIndent();
}

void PrintTouchDesc(Printer* printer,
                    const fuchsia_input_report::wire::TouchDescriptor& touch_desc) {
  printer->Print("Touch Descriptor:\n");
  printer->IncreaseIndent();
  if (touch_desc.has_input()) {
    printer->Print("Input Report:\n");
    printer->IncreaseIndent();
    const auto& input = touch_desc.input();
    if (input.has_touch_type()) {
      printer->Print("Touch Type: %s\n", Printer::TouchTypeToString(input.touch_type()));
    }
    if (input.has_max_contacts()) {
      printer->Print("Max Contacts: %ld\n", input.max_contacts());
    }
    if (input.has_contacts()) {
      for (size_t i = 0; i < input.contacts().count(); i++) {
        const fuchsia_input_report::wire::ContactInputDescriptor& contact = input.contacts()[i];

        printer->Print("Contact: %02d\n", i);
        printer->IncreaseIndent();

        if (contact.has_position_x()) {
          printer->Print("Position X:\n");
          printer->PrintAxisIndented(contact.position_x());
        }
        if (contact.has_position_y()) {
          printer->Print("Position Y:\n");
          printer->PrintAxisIndented(contact.position_y());
        }
        if (contact.has_pressure()) {
          printer->Print("Pressure:\n");
          printer->PrintAxisIndented(contact.pressure());
        }
        if (contact.has_contact_width()) {
          printer->Print("Contact Width:\n");
          printer->PrintAxisIndented(contact.contact_width());
        }
        if (contact.has_contact_height()) {
          printer->Print("Contact Height:\n");
          printer->PrintAxisIndented(contact.contact_height());
        }

        printer->DecreaseIndent();
      }
    }

    printer->DecreaseIndent();
  }

  if (touch_desc.has_feature()) {
    printer->Print("Feature Report:\n");
    printer->IncreaseIndent();
    const auto& feature = touch_desc.feature();
    printer->Print("Supports InputMode: %u\n",
                   feature.has_supports_input_mode() ? feature.supports_input_mode() : false);
    printer->Print("Supports SelectiveReporting: %u\n", feature.has_supports_selective_reporting()
                                                            ? feature.supports_selective_reporting()
                                                            : false);
    printer->DecreaseIndent();
  }
  printer->DecreaseIndent();
}

void PrintKeyboardDesc(Printer* printer,
                       const fuchsia_input_report::wire::KeyboardDescriptor& keyboard_desc) {
  printer->Print("Keyboard Descriptor:\n");

  if (keyboard_desc.has_input()) {
    const fuchsia_input_report::wire::KeyboardInputDescriptor& input = keyboard_desc.input();
    printer->Print("Input Report:\n");
    printer->IncreaseIndent();
    if (input.has_keys3()) {
      for (size_t i = 0; i < input.keys3().count(); i++) {
        printer->Print("Key: %8ld\n", input.keys3()[i]);
      }
    }
    printer->DecreaseIndent();
  }
  if (keyboard_desc.has_output()) {
    const fuchsia_input_report::wire::KeyboardOutputDescriptor& output = keyboard_desc.output();
    printer->Print("Output Report:\n");
    printer->IncreaseIndent();
    if (output.has_leds()) {
      for (size_t i = 0; i < output.leds().count(); i++) {
        printer->Print("Led: %s\n", Printer::LedTypeToString(output.leds()[i]));
      }
    }
    printer->DecreaseIndent();
  }
}

void PrintConsumerControlDesc(
    Printer* printer, const fuchsia_input_report::wire::ConsumerControlDescriptor& descriptor) {
  printer->Print("ConsumerControl Descriptor:\n");

  if (descriptor.has_input()) {
    const fuchsia_input_report::wire::ConsumerControlInputDescriptor& input = descriptor.input();
    printer->Print("Input Report:\n");
    printer->IncreaseIndent();
    if (input.has_buttons()) {
      for (size_t i = 0; i < input.buttons().count(); i++) {
        printer->Print("Button: %16s\n",
                       Printer::ConsumerControlButtonToString(input.buttons()[i]));
      }
    }
    printer->DecreaseIndent();
  }
}

void PrintInputReports(std::string filename, Printer* printer,
                       fidl::WireSharedClient<fuchsia_input_report::InputReportsReader> reader,
                       size_t num_reads, fit::closure callback) {
  if (num_reads == 0) {
    callback();
    return;
  }
  // Read the reports.
  // We need the ReadInputReport's callback to be mutable because the PrintInputReports callback is
  // moved into the next ReadInputReport's call.
  reader->ReadInputReports().ThenExactlyOnce(
      [=, filename = std::move(filename), reader = reader.Clone(), callback = std::move(callback)](
          fidl::WireUnownedResult<fuchsia_input_report::InputReportsReader::ReadInputReports>&
              call_result) mutable {
        if (!call_result.ok()) {
          return;
        }
        auto* result = call_result.Unwrap();
        size_t reads_left = num_reads;
        if (result->is_error()) {
          callback();
          return;
        }
        auto& reports = result->value()->reports;
        TRACE_DURATION("input", "print-input-report ReadReports");
        for (auto& report : reports) {
          if (reads_left == 0) {
            callback();
            return;
          }
          reads_left -= 1;
          printer->SetIndent(0);
          printer->Print("Report from file: %s\n", filename.c_str());
          if (report.has_event_time()) {
            printer->Print("EventTime: 0x%016lx\n", report.event_time());
          }
          if (report.has_trace_id()) {
            TRACE_FLOW_END("input", "input_report", report.trace_id());
          }
          if (report.has_report_id()) {
            printer->Print("ReportID: %02d\n", report.report_id());
          }
          if (report.has_mouse()) {
            auto& mouse = report.mouse();
            PrintMouseInputReport(printer, mouse);
          }
          if (report.has_sensor()) {
            PrintSensorInputReport(printer, report.sensor());
          }
          if (report.has_touch()) {
            PrintTouchInputReport(printer, report.touch());
          }
          if (report.has_keyboard()) {
            PrintKeyboardInputReport(printer, report.keyboard());
          }
          if (report.has_consumer_control()) {
            PrintConsumerControlInputReport(printer, report.consumer_control());
          }
          printer->Print("\n");
        }
        PrintInputReports(filename, printer, std::move(reader), reads_left, std::move(callback));
      });
}

void GetAndPrintInputReport(std::string filename,
                            fuchsia_input_report::wire::DeviceType device_type, Printer* printer,
                            fidl::WireSharedClient<fuchsia_input_report::InputDevice> client,
                            fit::closure callback) {
  client->GetInputReport(device_type)
      .ThenExactlyOnce(
          [=, filename = std::move(filename), callback = std::move(callback), _ = client.Clone()](
              fidl::WireUnownedResult<fuchsia_input_report::InputDevice::GetInputReport>&
                  call_result) {
            if (!call_result.ok()) {
              return;
            }
            auto* result = call_result.Unwrap();
            if (result->is_error()) {
              callback();
              return;
            }
            auto& report = result->value()->report;
            TRACE_DURATION("input", "print-input-report GetReport");
            printer->SetIndent(0);
            printer->Print("Report from file: %s\n", filename.c_str());
            if (report.has_event_time()) {
              printer->Print("EventTime: 0x%016lx\n", report.event_time());
            }
            if (report.has_trace_id()) {
              TRACE_FLOW_END("input", "input_report", report.trace_id());
            }
            if (report.has_report_id()) {
              printer->Print("ReportID: %02d\n", report.report_id());
            }
            if (report.has_mouse()) {
              auto& mouse = report.mouse();
              PrintMouseInputReport(printer, mouse);
            }
            if (report.has_sensor()) {
              PrintSensorInputReport(printer, report.sensor());
            }
            if (report.has_touch()) {
              PrintTouchInputReport(printer, report.touch());
            }
            if (report.has_keyboard()) {
              PrintKeyboardInputReport(printer, report.keyboard());
            }
            if (report.has_consumer_control()) {
              PrintConsumerControlInputReport(printer, report.consumer_control());
            }
            printer->Print("\n");
            callback();
          });
}

zx::result<fidl::WireSharedClient<fuchsia_input_report::InputReportsReader>> GetReaderClient(
    fidl::WireSharedClient<fuchsia_input_report::InputDevice>* client,
    async_dispatcher_t* dispatcher) {
  fidl::ClientEnd<fuchsia_input_report::InputReportsReader> reader_client;
  auto reader_server = fidl::CreateEndpoints(&reader_client);
  if (reader_server.is_error()) {
    return reader_server.take_error();
  }
  auto result = (*client)->GetInputReportsReader(std::move(*reader_server));

  if (result.status() != ZX_OK) {
    return zx::error(result.status());
  }

  return zx::ok(fidl::WireSharedClient(std::move(reader_client), dispatcher));
}

void PrintMouseInputReport(Printer* printer,
                           const fuchsia_input_report::wire::MouseInputReport& mouse_report) {
  if (mouse_report.has_movement_x()) {
    printer->Print("Movement x: %08ld\n", mouse_report.movement_x());
  }
  if (mouse_report.has_movement_y()) {
    printer->Print("Movement y: %08ld\n", mouse_report.movement_y());
  }
  if (mouse_report.has_position_x()) {
    printer->Print("Position x: %08ld\n", mouse_report.position_x());
  }
  if (mouse_report.has_position_y()) {
    printer->Print("Position y: %08ld\n", mouse_report.position_y());
  }
  if (mouse_report.has_scroll_v()) {
    printer->Print("Scroll v: %08ld\n", mouse_report.scroll_v());
  }
  if (mouse_report.has_pressed_buttons()) {
    for (uint8_t button : mouse_report.pressed_buttons()) {
      printer->Print("Button %02d pressed\n", button);
    }
  }
}

void PrintSensorInputReport(Printer* printer,
                            const fuchsia_input_report::wire::SensorInputReport& sensor_report) {
  if (!sensor_report.has_values()) {
    return;
  }

  for (size_t i = 0; i < sensor_report.values().count(); i++) {
    printer->Print("Sensor[%02d]: %08d\n", i, sensor_report.values()[i]);
  }
}

void PrintTouchInputReport(Printer* printer,
                           const fuchsia_input_report::wire::TouchInputReport& touch_report) {
  if (touch_report.has_contacts()) {
    for (size_t i = 0; i < touch_report.contacts().count(); i++) {
      const fuchsia_input_report::wire::ContactInputReport& contact = touch_report.contacts()[i];

      if (contact.has_contact_id()) {
        printer->Print("Contact ID: %2ld\n", contact.contact_id());
      } else {
        printer->Print("Contact: %2d\n", i);
      }

      printer->IncreaseIndent();
      if (contact.has_position_x()) {
        printer->Print("Position X:     %08ld\n", contact.position_x());
      }
      if (contact.has_position_y()) {
        printer->Print("Position Y:     %08ld\n", contact.position_y());
      }
      if (contact.has_pressure()) {
        printer->Print("Pressure:       %08ld\n", contact.pressure());
      }
      if (contact.has_contact_width()) {
        printer->Print("Contact Width:  %08ld\n", contact.contact_width());
      }
      if (contact.has_contact_height()) {
        printer->Print("Contact Height: %08ld\n", contact.contact_height());
      }
      if (contact.has_confidence()) {
        printer->Print("Confidence: %d\n", contact.confidence());
      }

      printer->DecreaseIndent();
    }
  }
}

void PrintKeyboardInputReport(
    Printer* printer, const fuchsia_input_report::wire::KeyboardInputReport& keyboard_report) {
  printer->Print("Keyboard Report\n");
  printer->IncreaseIndent();
  if (keyboard_report.has_pressed_keys3()) {
    for (size_t i = 0; i < keyboard_report.pressed_keys3().count(); i++) {
      printer->Print("Key: %8ld\n", keyboard_report.pressed_keys3()[i]);
    }
    if (keyboard_report.pressed_keys3().count() == 0) {
      printer->Print("No keys pressed\n");
    }
  }
  printer->DecreaseIndent();
}

void PrintConsumerControlInputReport(
    Printer* printer, const fuchsia_input_report::wire::ConsumerControlInputReport& report) {
  printer->Print("ConsumerControl Report\n");
  printer->IncreaseIndent();
  if (report.has_pressed_buttons()) {
    for (size_t i = 0; i < report.pressed_buttons().count(); i++) {
      printer->Print("Button: %16s\n",
                     Printer::ConsumerControlButtonToString(report.pressed_buttons()[i]));
    }
  }
  printer->DecreaseIndent();
}

}  // namespace print_input_report